{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright (c) MONAI Consortium  \n",
    "Licensed under the Apache License, Version 2.0 (the \"License\");  \n",
    "you may not use this file except in compliance with the License.  \n",
    "You may obtain a copy of the License at  \n",
    "&nbsp;&nbsp;&nbsp;&nbsp;http://www.apache.org/licenses/LICENSE-2.0  \n",
    "Unless required by applicable law or agreed to in writing, software  \n",
    "distributed under the License is distributed on an \"AS IS\" BASIS,  \n",
    "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  \n",
    "See the License for the specific language governing permissions and  \n",
    "limitations under the License."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MONAI pipeline with PyTorch 2.0 Features\n",
    "\n",
    "This notebook introduces how to use `torch.compile` in the MONAI pipeline. `torch.compile` is the main API for PyTorch 2.0, which wraps your model and returns a compiled model. It is a fully additive (and optional) feature and hence 2.0 is 100% backward compatible by definition. We also run an end-to-end pipeline based on [\"fast_training_tutorial.ipynb\"](https://github.com/Project-MONAI/tutorials/blob/main/acceleration/fast_training_tutorial.ipynb), and the speed up is 1.16x."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python -c \"import monai\" || pip install -q \"monai-weekly[nibabel, matplotlib]\"\n",
    "# %pip install -q torch==2.1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import torch\n",
    "import shutil\n",
    "import tempfile\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import monai\n",
    "import monai.transforms as mt\n",
    "from monai.config import print_config\n",
    "from monai.utils import set_determinism\n",
    "from monai.bundle import download, create_workflow\n",
    "from monai.engines import SupervisedTrainer\n",
    "\n",
    "print_config()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup data directory\n",
    "\n",
    "You can specify a directory with the `MONAI_DATA_DIRECTORY` environment variable.  \n",
    "This allows you to save results and reuse downloads.  \n",
    "If not specified, a temporary directory will be used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/workspace/Data\n"
     ]
    }
   ],
   "source": [
    "directory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\n",
    "if directory is not None:\n",
    "    os.makedirs(directory, exist_ok=True)\n",
    "root_dir = tempfile.mkdtemp() if directory is None else directory\n",
    "print(root_dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Download dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024-02-26 10:29:47,048 - INFO - Expected md5 is None, skip md5 check for file samples.zip.\n",
      "2024-02-26 10:29:47,049 - INFO - File exists: samples.zip, skipped downloading.\n",
      "2024-02-26 10:29:47,051 - INFO - Writing into directory: /workspace/Data.\n"
     ]
    }
   ],
   "source": [
    "sample_url = \"https://github.com/Project-MONAI/MONAI-extra-test-data/releases\"\n",
    "sample_url += \"/download/0.8.1/totalSegmentator_mergedLabel_samples.zip\"\n",
    "monai.apps.download_and_extract(sample_url, output_dir=root_dir, filepath=\"samples.zip\")\n",
    "\n",
    "base_name = os.path.join(root_dir, \"totalSegmentator_mergedLabel_samples\")\n",
    "input_data = []\n",
    "for filename in os.listdir(os.path.join(base_name, \"imagesTr\")):\n",
    "    input_data.append(\n",
    "        {\n",
    "            \"image\": os.path.join(base_name, \"imagesTr\", filename),\n",
    "            \"label\": os.path.join(base_name, \"labelsTr\", filename),\n",
    "        }\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set deterministic for reproducibility"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "set_determinism(seed=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set up timing and training functions\n",
    "\n",
    "For best accuracies, we use CUDA events and synchronization to measure the forward and backward propagations in training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def timed(fn):\n",
    "    start = torch.cuda.Event(enable_timing=True)\n",
    "    end = torch.cuda.Event(enable_timing=True)\n",
    "    start.record()\n",
    "    result = fn()\n",
    "    end.record()\n",
    "    torch.cuda.synchronize()\n",
    "    return result, start.elapsed_time(end) / 1000\n",
    "\n",
    "\n",
    "def train(model, inputs, labels):\n",
    "    outputs = model(inputs)\n",
    "    loss_function = monai.losses.DiceCELoss(to_onehot_y=True, softmax=True)\n",
    "    loss = loss_function(outputs, labels)\n",
    "    loss.backward()\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set up model\n",
    "\n",
    "Here we used `create_workflow` to get the network instance from the bundle. You can also initialize your own network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024-02-26 10:29:57,384 - INFO - --- input summary of monai.bundle.scripts.download ---\n",
      "2024-02-26 10:29:57,386 - INFO - > name: 'wholeBody_ct_segmentation'\n",
      "2024-02-26 10:29:57,386 - INFO - > bundle_dir: './bundle'\n",
      "2024-02-26 10:29:57,387 - INFO - > source: 'monaihosting'\n",
      "2024-02-26 10:29:57,388 - INFO - > remove_prefix: 'monai_'\n",
      "2024-02-26 10:29:57,389 - INFO - > progress: True\n",
      "2024-02-26 10:29:57,391 - INFO - ---\n",
      "\n",
      "\n",
      "2024-02-26 10:29:57,559 - INFO - Expected md5 is None, skip md5 check for file bundle/wholeBody_ct_segmentation_v0.2.2.zip.\n",
      "2024-02-26 10:29:57,560 - INFO - File exists: bundle/wholeBody_ct_segmentation_v0.2.2.zip, skipped downloading.\n",
      "2024-02-26 10:29:57,560 - INFO - Writing into directory: bundle.\n",
      "2024-02-26 10:29:58,542 - INFO - --- input summary of monai.bundle.scripts.run ---\n",
      "2024-02-26 10:29:58,543 - INFO - > config_file: './bundle/wholeBody_ct_segmentation/configs/train.json'\n",
      "2024-02-26 10:29:58,544 - INFO - > workflow_type: 'train'\n",
      "2024-02-26 10:29:58,544 - INFO - ---\n",
      "\n",
      "\n",
      "2024-02-26 10:29:58,545 - INFO - Setting logging properties based on config: bundle/wholeBody_ct_segmentation/configs/logging.conf.\n"
     ]
    }
   ],
   "source": [
    "device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n",
    "bundle_dir = \"./bundle\"\n",
    "os.makedirs(bundle_dir, exist_ok=True)\n",
    "\n",
    "bundle = download(\"wholeBody_ct_segmentation\", bundle_dir=bundle_dir)\n",
    "config_file = os.path.join(bundle_dir, \"wholeBody_ct_segmentation/configs/train.json\")\n",
    "train_workflow = create_workflow(config_file=str(config_file), workflow_type=\"train\")\n",
    "\n",
    "\n",
    "def init_model(device):\n",
    "    return train_workflow.network_def.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set up DataLoader and train transforms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading dataset:   0%|          | 0/20 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading dataset: 100%|██████████| 20/20 [00:06<00:00,  2.94it/s]\n"
     ]
    }
   ],
   "source": [
    "device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n",
    "\n",
    "transform = mt.Compose(\n",
    "    [\n",
    "        mt.LoadImageD(keys=(\"image\", \"label\"), image_only=True, ensure_channel_first=True),\n",
    "        mt.SpacingD(keys=(\"image\", \"label\"), pixdim=1.5),\n",
    "        mt.EnsureTypeD(keys=(\"image\", \"label\"), device=device),\n",
    "        mt.RandRotateD(\n",
    "            keys=(\"image\", \"label\"),\n",
    "            prob=1.0,\n",
    "            range_x=0.1,\n",
    "            range_y=0.1,\n",
    "            range_z=0.3,\n",
    "            mode=(\"bilinear\", \"nearest\"),\n",
    "        ),\n",
    "        mt.RandZoomD(keys=(\"image\", \"label\"), prob=1.0, min_zoom=0.8, max_zoom=1.2, mode=(\"trilinear\", \"nearest\")),\n",
    "        mt.ResizeWithPadOrCropD(keys=(\"image\", \"label\"), spatial_size=(96, 96, 96)),\n",
    "        # add `FromMetaTensorD` to convert `MetaTensor` to `torch.Tensor`\n",
    "        mt.FromMetaTensorD(keys=(\"image\", \"label\")),\n",
    "    ]\n",
    ")\n",
    "\n",
    "dataset = monai.data.CacheDataset(data=input_data, transform=transform, cache_rate=1.0, num_workers=4)\n",
    "data_loader = monai.data.DataLoader(dataset, batch_size=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training in eager mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 1/50 average loss: 5.3303, time: 4.0818\n",
      "epoch 2/50 average loss: 4.8197, time: 1.6785\n",
      "epoch 3/50 average loss: 4.3100, time: 1.6776\n",
      "epoch 4/50 average loss: 3.7214, time: 1.6770\n",
      "epoch 5/50 average loss: 3.4800, time: 1.6763\n",
      "mean training time per iteration: 0.0863 seconds\n"
     ]
    }
   ],
   "source": [
    "# start a typical PyTorch training\n",
    "epoch_num = 50\n",
    "model = init_model(device)\n",
    "optimizer = torch.optim.Adam(model.parameters(), 1e-3)\n",
    "\n",
    "epoch_loss_values = []\n",
    "eager_time = []\n",
    "for epoch in range(epoch_num):\n",
    "    model.train()\n",
    "    epoch_loss = 0\n",
    "    step = 0\n",
    "    for batch_data in data_loader:\n",
    "        step += 1\n",
    "        inputs, labels = batch_data[\"image\"].to(device), batch_data[\"label\"].to(device)\n",
    "        optimizer.zero_grad()\n",
    "        loss, train_time = timed(lambda: train(model, inputs, labels))  # noqa: B023\n",
    "        optimizer.step()\n",
    "        epoch_loss += loss.item()\n",
    "        eager_time.append(train_time)\n",
    "    epoch_loss /= step\n",
    "    epoch_loss_values.append(epoch_loss)\n",
    "    if epoch < 5:\n",
    "        print(\n",
    "            f\"epoch {epoch + 1}/{epoch_num} average loss: {epoch_loss:.4f}, \"\n",
    "            f\"time: {sum(eager_time[epoch*step: epoch*step+step]):.4f}\"\n",
    "        )\n",
    "print(f\"mean training time per iteration: {np.mean(eager_time):.4f} seconds\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train the model with torch.compile\n",
    "\n",
    "The only difference is that we wrap the model with `torch.compile`. You may also see different speedup results depending on the chosen mode argument. The \"reduce-overhead\" mode uses CUDA graphs to further reduce the overhead of Python. For your own models, you may need to experiment with different modes to maximize speedup. You can read more about modes [here](https://pytorch.org/get-started/pytorch-2.0/#user-experience)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_opt = torch.compile(init_model(device), mode=\"reduce-overhead\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using FallbackKernel: aten.upsample_trilinear3d\n",
      "Using FallbackKernel: aten.upsample_trilinear3d_backward\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 1/50 average loss: 2.6643, time: 25.8817\n",
      "epoch 2/50 average loss: 2.7037, time: 1.0575\n",
      "epoch 3/50 average loss: 2.6043, time: 1.0573\n",
      "epoch 4/50 average loss: 2.5799, time: 1.0586\n",
      "epoch 5/50 average loss: 2.6259, time: 1.0585\n",
      "mean training time per iteration after compilation: 0.0778 seconds\n"
     ]
    }
   ],
   "source": [
    "# start a typical PyTorch training\n",
    "optimizer = torch.optim.Adam(model_opt.parameters(), 1e-3)\n",
    "\n",
    "epoch_loss_values = []\n",
    "compile_time = []\n",
    "for epoch in range(epoch_num):\n",
    "    model_opt.train()\n",
    "    epoch_loss = 0\n",
    "    step = 0\n",
    "    for batch_data in data_loader:\n",
    "        step += 1\n",
    "        inputs, labels = batch_data[\"image\"].to(device), batch_data[\"label\"].to(device)\n",
    "        optimizer.zero_grad()\n",
    "        loss, train_time = timed(lambda: train(model_opt, inputs, labels))  # noqa: B023\n",
    "        optimizer.step()\n",
    "        epoch_loss += loss.item()\n",
    "        compile_time.append(train_time)\n",
    "    epoch_loss /= step\n",
    "    epoch_loss_values.append(epoch_loss)\n",
    "    if epoch < 5:\n",
    "        print(\n",
    "            f\"epoch {epoch + 1}/{epoch_num} average loss: {epoch_loss:.4f}, \"\n",
    "            f\"time: {sum(compile_time[epoch*step: epoch*step+step]):.4f}\"\n",
    "        )\n",
    "print(f\"mean training time per iteration after compilation: {np.mean(compile_time):.4f} seconds\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Demonstrate the speedups\n",
    "As [torch](https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html) mentioned, we can see that `torch.compile` takes longer in the first epoch, as it must compile the model, but in subsequent iterations, we can see a significant improvement compared to eager. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first iteration: 2.488s(eager mode) vs. 23.759s(compile mode)\n",
      "eager mean: 0.08626252268981932, compile mean: 0.07776330187988281, speedup: 1.1092960381628965x\n"
     ]
    }
   ],
   "source": [
    "print(f\"first iteration: {eager_time[0]:.3f}s(eager mode) vs. {compile_time[0]:.3f}s(compile mode)\")\n",
    "\n",
    "speedup = np.mean(eager_time) / np.mean(compile_time)\n",
    "print(f\"eager mean: {np.mean(eager_time)}, compile mean: {np.mean(compile_time)}, speedup: {speedup}x\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot total time and every epoch time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f2e597708b0>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+QAAAIjCAYAAACKx9GpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAADJDUlEQVR4nOzdf3xT1f0/8Ne5SZu2oQ0t0B+UQisiP0SQoXaAgiID2aaiqPMz/fhjOtxE/eCPoW6Kuql8BIeoc7i5z0Td/D1/ze82UUHQgYioyIaiIv1BLaWlkNKWpk3O+f5RcteQtE1O015u8nry6IPb9CY555Xb3nty3vdGKKUUiIiIiIiIiKhPGVY3gIiIiIiIiCgZcUBOREREREREZAEOyImIiIiIiIgswAE5ERERERERkQU4ICciIiIiIiKyAAfkRERERERERBbggJyIiIiIiIjIAhyQExEREREREVmAA3IiIiIiIiIiC3BATgntnXfegRAC77zzjtVNwWWXXYbi4uI+f94777wTQog+f96OlixZglGjRkFKaWk77Cy4Lb/44os9fqy2tjYUFRXht7/9bRxaRkREdrNy5UoIIfDhhx/26vOceuqpOPXUU3v1OYjsjgNyijshRFRf0QyS7733Xrzyyiu2aW9fKS4ujqrNK1eutLqpaGhowH333Yebb74ZhvGfPznXX389vvWtbyEnJwcZGRkYPXo07rzzTjQ2NoY9hs/nw80334zBgwcjPT0dpaWlePPNNyM+3/r163HyyScjIyMD+fn5uO666yI+ZjJLSUnBDTfcgHvuuQctLS1WN4eIKOEEB7ydfb3//vtWN1FLWVlZ1MdNZWVlVjeXyBacVjeAEs9TTz0V8v2TTz6JN998M+z20aNHd/tY9957L8477zzMmTMnnk0MEc/2duWxxx6L2wzx8uXLQwaZf/vb3/DMM8/ggQcewMCBA83bJ0+ejIsvvhi33HJLXJ5Xxx//+Ef4/X7813/9V8jtmzZtwimnnILLL78caWlp+Pjjj/G///u/eOutt7Bu3bqQwftll12GF198EQsWLMCIESOwcuVKfPe738WaNWtw8sknm+t98sknOP300zF69GgsW7YMu3btwv33348vv/wSf//73/usz3Zw+eWX45ZbbsHTTz+NH/3oR1Y3h4goIf3yl79ESUlJ2O1HH320Ba3puUGDBoUdH/3617/Grl278MADD4Stu2rVqr5sHpEtcUBOcXfxxReHfP/+++/jzTffDLv9SKHb3ubmZmRkZET9PCkpKVrti+TwNyh2796NZ555BnPmzIlYFu90Wver/vjjj+Oss85CWlpayO3vvfde2LrDhw/HTTfdhA8++ADf/va3AQAffPABnn32WSxduhQ33XQTAOCSSy7B2LFjsXDhQqxfv968/89//nNkZ2fjnXfeQVZWFoD2aoIf//jHWLVqFWbOnNlb3bSd/v37Y+bMmVi5ciUH5EREvWT27Nk44YQTrG5G3Ljd7rDjo2effRb79u07Yo/ziI50LFknSzQ1NeHGG29EUVERXC4XRo4cifvvvx9KKXMdIQSamprwxBNPmOVPl112GQCgvLwcV199NUaOHIn09HQMGDAA559/fq+VR5166qkYO3YsNm/ejKlTpyIjIwM///nPAQCvvvoqvve972Hw4MFwuVwYPnw4fvWrXyEQCIQ8xuHnkAfLvu6//378/ve/x/Dhw+FyuXDiiSdi06ZNcWt7pHPIhRC45ppr8MILL2DMmDFIT0/HpEmTsHXrVgDA7373Oxx99NFIS0vDqaeeGjHXjRs34owzzoDH40FGRgamTZuGf/7znyHr7Ny5E59++ilmzJgRVVuD+ezfv9+87cUXX4TD4cC8efPM29LS0nDFFVdgw4YNqKysBNBeGh98IyU4GAfaB+/9+vXD888/3+3z+3w+3HHHHTj66KPhcrlQVFSEhQsXwufzhawXzO/Pf/4zRo4cibS0NEycOBHr1q0Le8yPP/4Ys2fPRlZWFvr164fTTz89Yqni/v37cf3116O4uBgulwtDhgzBJZdcgrq6upD1pJS45557MGTIEKSlpeH000/HV199FbLOl19+iblz5yI/Px9paWkYMmQILrzwQni93pD1vvOd7+C9995DfX19t9kQEVH8dTwWeOCBBzBs2DCkp6dj2rRp+Ne//hW2/urVq3HKKafA7Xajf//+OPvss/HZZ5+FrVdVVYUrrrjCPDYpKSnBT3/6U7S2toas5/P5cMMNN2DQoEFwu90455xzUFtbG7f+HX4OefB6KM8//zzuuusuFBYWIjMzE+eddx68Xi98Ph8WLFiA3Nxc9OvXD5dffnnYPhgA/vSnP2HixIlIT09HTk4OLrzwQvN4gMhuOENOfU4phbPOOgtr1qzBFVdcgeOPPx5vvPEGfvazn6GqqsoseXrqqadw5ZVX4qSTTjIHY8OHDwfQXu68fv16XHjhhRgyZAjKysqwYsUKnHrqqdi2bVtMM9fR2rt3L2bPno0LL7wQF198MfLy8gC0nyfWr18/3HDDDejXrx9Wr16NRYsWoaGhAUuXLu32cZ9++mkcOHAAV111FYQQWLJkCc4991x8/fXXcZ1VP9y7776L1157DfPnzwcALF68GN///vexcOFC/Pa3v8XVV1+Nffv2YcmSJfjRj36E1atXm/ddvXo1Zs+ejYkTJ+KOO+6AYRh4/PHHMX36dLz77rs46aSTAMCcvf7Wt74VsQ1+vx/79+9Ha2sr/vWvf+G2225DZmameX+gfUB7zDHHhAyyAZjrfPLJJygqKsLWrVvh9/vDZiJSU1Nx/PHH4+OPP+4yDyklzjrrLLz33nuYN28eRo8eja1bt+KBBx7AF198EXYtg7Vr1+K5557DddddB5fLhd/+9rc444wz8MEHH2Ds2LEAgH//+9845ZRTkJWVhYULFyIlJQW/+93vcOqpp2Lt2rUoLS0FADQ2NuKUU07BZ599hh/96Ef41re+hbq6Orz22mvYtWtXyGkI//u//wvDMHDTTTfB6/ViyZIluOiii7Bx40YAQGtrK2bNmgWfz4drr70W+fn5qKqqwuuvv479+/fD4/GYjzVx4kQopbB+/Xp8//vf7zIfIiKKndfrDXtjVQiBAQMGhNz25JNP4sCBA5g/fz5aWlrw4IMPYvr06di6dat5vPHWW29h9uzZOOqoo3DnnXfi4MGDePjhhzFlyhR89NFH5pva33zzDU466STs378f8+bNw6hRo1BVVYUXX3wRzc3NSE1NNZ/32muvRXZ2Nu644w6UlZVh+fLluOaaa/Dcc8/1ai6LFy9Geno6brnlFnz11Vd4+OGHkZKSAsMwsG/fPtx55514//33sXLlSpSUlGDRokXmfe+55x7cfvvtuOCCC3DllVeitrYWDz/8MKZOnYqPP/4Y/fv379W2E8WdIupl8+fPVx03tVdeeUUBUHfffXfIeuedd54SQqivvvrKvM3tdqtLL7007DGbm5vDbtuwYYMCoJ588knztjVr1igAas2aNdrtVUqpadOmKQDq0UcfjaotV111lcrIyFAtLS3mbZdeeqkaNmyY+f3OnTsVADVgwABVX19v3v7qq68qAOqvf/1r1G1eunSpAqB27twZ9rM77rgjrD8AlMvlCln/d7/7nQKg8vPzVUNDg3n7rbfeGvLYUko1YsQINWvWLCWlNNdrbm5WJSUl6jvf+Y5522233aYAqAMHDkRsd/A1C36NHDky7LU69thj1fTp08Pu++9//zvkNXnhhRcUALVu3bqwdc8//3yVn58fsQ1BTz31lDIMQ7377rshtz/66KMKgPrnP/9p3hZs74cffmjeVl5ertLS0tQ555xj3jZnzhyVmpqqduzYYd72zTffqMzMTDV16lTztkWLFikA6qWXXgprVzDj4LY8evRo5fP5zJ8/+OCDCoDaunWrUkqpjz/+WAFQL7zwQpf9DbYFgLrvvvu6XZeIiKL3+OOPh+zfOn65XC5zveCxQHp6utq1a5d5+8aNGxUAdf3115u3HX/88So3N1ft3bvXvG3Lli3KMAx1ySWXmLddcsklyjAMtWnTprB2BfcpwfbNmDEjZF9+/fXXK4fDofbv3x91X7/3ve+FHN90NG3aNDVt2jTz++C+bOzYsaq1tdW8/b/+67+UEELNnj075P6TJk0KeeyysjLlcDjUPffcE7Le1q1bldPpDLudyA5Ysk597m9/+xscDgeuu+66kNtvvPFGKKWiuvhWenq6udzW1oa9e/fi6KOPRv/+/fHRRx/Fvc0A4HK5cPnll3fZlgMHDqCurg6nnHIKmpub8fnnn3f7uD/4wQ+QnZ1tfn/KKacAAL7++us4tLpzp59+ekgJfXC2du7cucjMzAy7PdieTz75BF9++SV++MMfYu/evairq0NdXR2amppw+umnY926debF6/bu3Qun04l+/fpFbMOYMWPw5ptv4pVXXsHChQvhdrvDroh+8OBBuFyusPsGz0k/ePBgyP+drRv8eWdeeOEFjB49GqNGjTL7VFdXh+nTpwMA1qxZE7L+pEmTMHHiRPP7oUOH4uyzz8Ybb7yBQCCAQCCAVatWYc6cOTjqqKPM9QoKCvDDH/4Q7733HhoaGgAAf/nLXzB+/Hicc845Ye06/HSDyy+/PGR24/DtJTgD/sYbb6C5ubnLPge3u8Nnb4iIKD4eeeQRvPnmmyFfkY5z5syZg8LCQvP7k046CaWlpfjb3/4GAKiursYnn3yCyy67DDk5OeZ648aNw3e+8x1zPSklXnnlFZx55pkRz10/fJ8yb968kNtOOeUUBAIBlJeX96zj3bjkkktCqgBLS0uhlAq7pklpaSkqKyvh9/sBAC+99BKklLjgggtC9tX5+fkYMWJE2L6ayA5Ysk59rry8HIMHDw4Z9AH/uYp5NDuBgwcPYvHixXj88cdRVVUVcu754efJxkthYWHIQCjo3//+N2677TasXr3aHGDF0pahQ4eGfB8cJO3bt68Hre3e4c8bHMgVFRVFvD3Yni+//BIAcOmll3b62F6vN+RNhs5kZWWZ55efffbZePrpp3H22Wfjo48+wvjx4wG0v+ER6fyx4Md1Bd8QCf7f2bod3ziJ5Msvv8Rnn32GQYMGRfz5nj17Qr4fMWJE2DrHHHMMmpubzfPvmpubMXLkyLD1Ro8eDSklKisrceyxx2LHjh2YO3dul+0L6m57KSkpwQ033IBly5bhz3/+M0455RScddZZuPjii0PK1QGYvzdWf049EVGiOumkk6K6qFtn+5Tg9U+Cx0ad7VPeeOMNNDU1obGxEQ0NDeapU92xwzGIlBJerxcDBgzAl19+CaVUxLyA+F5Al6ivcEBOtnTttdfi8ccfx4IFCzBp0iR4PB4IIXDhhRfG7aPFDhdpQLd//35MmzYNWVlZ+OUvf4nhw4cjLS0NH330EW6++eao2uJwOCLe3vFNht7Q2fN2155gn5YuXYrjjz8+4rrBGfEBAwbA7/fjwIEDYW/ARHLuuefiv//7v/Hss8+aA/KCggJUVVWFrVtdXQ0AGDx4sLlex9sPXze4XmeklDjuuOOwbNmyiD8//CDBKtFsL7/+9a9x2WWX4dVXX8WqVatw3XXXYfHixXj//fcxZMgQc73gAVfHc9SJiCh52PEYRAiBv//97xHX7awij+hIxgE59blhw4bhrbfeChukBcu7hw0bZt7W2czdiy++iEsvvRS//vWvzdtaWlpCrs7dF9555x3s3bsXL730EqZOnWrevnPnzj5tR18KXliv4+x2Z0aNGgWgPY9x48Z1+9g+n898Jzzo+OOPx5o1a9DQ0BByYbfgRcyCbwqMHTsWTqcTH374IS644AJzvdbWVnzyyScht3XWry1btuD000+PasY4WCnQ0RdffIGMjAxzlj0jIwPbt28PW+/zzz+HYRjmIH/48OERr6bbE8cddxyOO+443HbbbVi/fj2mTJmCRx99FHfffbe5TnA7DVanEBGRNTrbpwRPLQseG3W2Txk4cCDcbjfS09ORlZUV933KkWL48OFQSqGkpATHHHOM1c0higueQ0597rvf/S4CgQB+85vfhNz+wAMPQAiB2bNnm7e53e6Ig2yHwxH27u3DDz8c9lFjvS347mzHtrS2tuK3v/1tn7ajL02cOBHDhw/H/fffH3a+N4CQj0uZNGkSAODDDz8MWWf//v1oa2sLu+8f/vAHAAgp7zvvvPMQCATw+9//3rzN5/Ph8ccfR2lpqTmo9Xg8mDFjBv70pz/hwIED5rpPPfUUGhsbcf7553fZrwsuuABVVVV47LHHwn528OBBNDU1hdy2YcOGkOsVVFZW4tVXX8XMmTPhcDjgcDgwc+ZMvPrqqyEfG1dTU4Onn34aJ598svkGw9y5c7Flyxa8/PLLYc8d6yxFQ0ODea5d0HHHHQfDMMLK+Tdv3gwhhPk6ERGRNV555ZWQarAPPvgAGzduNI+JCgoKcPzxx+OJJ54IOS7617/+hVWrVuG73/0uAMAwDMyZMwd//etfw/a9QO/PfPe2c889Fw6HA3fddVdYX5RS2Lt3r0UtI9LHGXLqc2eeeSZOO+00/OIXv0BZWRnGjx+PVatW4dVXX8WCBQvMGVigffD31ltvYdmyZRg8eDBKSkpQWlqK73//+3jqqafg8XgwZswYbNiwAW+99VbYx4j0tsmTJyM7OxuXXnoprrvuOggh8NRTT9l+h9cVwzDwhz/8AbNnz8axxx6Lyy+/HIWFhaiqqsKaNWuQlZWFv/71rwCAo446CmPHjsVbb70VcqGWd955B9dddx3OO+88jBgxAq2trXj33Xfx0ksv4YQTTsDFF19srltaWorzzz8ft956K/bs2YOjjz4aTzzxBMrKyvB///d/IW275557MHnyZEybNg3z5s3Drl278Otf/xozZ87EGWec0WW//vu//xvPP/88fvKTn2DNmjWYMmUKAoEAPv/8czz//PN44403Qt4oGDt2LGbNmhXysWcAcNddd5nr3H333XjzzTdx8skn4+qrr4bT6cTvfvc7+Hw+LFmyxFzvZz/7GV588UWcf/75+NGPfoSJEyeivr4er732Gh599FGzfD8aq1evxjXXXIPzzz8fxxxzDPx+P5566ik4HI6w89TffPNNTJkypc9/b4iIksXf//73iBd4nTx5csgFP48++micfPLJ+OlPfwqfz4fly5djwIABWLhwobnO0qVLMXv2bEyaNAlXXHGF+bFnHo8Hd955p7nevffei1WrVpn7wtGjR6O6uhovvPAC3nvvPVt/LNjw4cNx991349Zbb0VZWRnmzJmDzMxM7Ny5Ey+//DLmzZuHm266yepmEsWEA3Lqc4Zh4LXXXsOiRYvw3HPP4fHHH0dxcTGWLl2KG2+8MWTdZcuWYd68ebjttttw8OBBXHrppSgtLcWDDz4Ih8OBP//5z2hpacGUKVPw1ltvYdasWX3alwEDBuD111/HjTfeiNtuuw3Z2dm4+OKLcfrpp/d5W/rSqaeeig0bNuBXv/oVfvOb36CxsRH5+fkoLS3FVVddFbLuj370IyxatAgHDx40z8M/7rjjcNppp+HVV19FdXU1lFIYPnw4Fi1ahJ/97GdhF8978skncfvtt+Opp57Cvn37MG7cOLz++ushpwkA7Z93/tZbb+Hmm2/G9ddfj8zMTFxxxRVYvHhxt30yDAOvvPIKHnjgATz55JN4+eWXkZGRgaOOOgr/8z//E1YaN23aNEyaNAl33XUXKioqMGbMGKxcuTKkNP/YY4/Fu+++i1tvvRWLFy+GlBKlpaX405/+ZF69Hmg/5+3dd9/FHXfcgZdffhlPPPEEcnNzcfrpp4ec8x2N8ePHY9asWfjrX/+KqqoqZGRkYPz48fj73/+Ob3/72+Z6Xq8Xq1atSuhqDiIiq3X8/OyOHn/88ZAB+SWXXALDMLB8+XLs2bMHJ510En7zm9+Y10cBgBkzZuAf//gH7rjjDixatAgpKSmYNm0a7rvvPpSUlJjrFRYWYuPGjbj99tvx5z//GQ0NDSgsLMTs2bORkZHRe53tI7fccguOOeYYPPDAA+ab4EVFRZg5cybOOussi1tHFDuhEnkqj4gs5/V6cdRRR2HJkiW44oorrG5OXAghMH/+/LDTLuxk+fLlWLJkCXbs2NHtFeiJiKh3lJWVoaSkBEuXLuXMLlGS4jnkRNSrPB4PFi5ciKVLl/baFfApNm1tbVi2bBluu+02DsaJiIiILMSSdSLqdTfffDNuvvlmq5tBh6SkpKCiosLqZhARERElPc6QExEREREREVmA55ATERERERERWYAz5EREREREREQW4ICciIiIiIiIyAIJf1E3KSW++eYbZGZmQghhdXOIiIiglMKBAwcwePBgGAbfG+8p7uuJiOhIE+2+PuEH5N988w2KioqsbgYREVGYyspKDBkyxOpm2B739UREdKTqbl+f8APyzMxMAO1BZGVlWdwaIiIioKGhAUVFReY+inqG+3oiIjrSRLuvT/gBebB0LSsriztpm5NSorKyEkVFRSzxpKTD7T8xsbw6PmLd1/P3SQ9z08Pc9DE7PcxNX29k192+nq8Q2YYQAgUFBTyApaTE7Z8ofvj7pIe56WFu+pidHuamz4rsEn6GnBKHEAKpqalWN4PIEtz+ieKHv096mJse5qaP2elhbvqsyI4z5GQbUkqUlZVBSml1U4j6HLd/ovjh75Me5qaHueljdnqYmz4rsuMMOdovSe/3+xEIBKxuCnVBKYWBAwfC5/MlZAmOw+GA0+lMyL5RzwkhMGTIEG4fRHHA3yc9zE0Pc9PXWXaBQABtbW0WterIl+jHzL0pluzideye9APy1tZWVFdXo7m52eqmUBSUUgn9hyUjIwMFBQUsM6IwQggYhpHQ2z9RX+Hvkx7mpoe56YuUXWNjI3bt2gWllIUtO/Il+jFzb4olu3gcuyf1gFxKiZ07d8LhcGDw4MFITU3lhnsEU0qhra0NKSkpCfc6KaXQ2tqK2tpa7Ny5EyNGjOBVMSmElBIVFRUYOnQotw2iHuLvkx7mpoe56Ts8u0AggF27diEjIwODBg1KuOPBeEnkY+beFm128Tx2T+oBeWtrK6SUKCoqQkZGhtXNoSikpaUl7B+W9PR0pKSkoLy8HK2trUhLS7O6SXQEMQyDB3NEccLfJz3MTQ9z03d4dm1tbVBKYdCgQUhPT7e4dUe2RD5m7m3RZhevY3f+ZQD4B9ImgqVJiVyixG2ROqOUgpQyobd/or7C3yc9zE0Pc9PXWXYcaHYtGY6Ze0us2cXj2J1H/2Qrra2tVjeByBJKKZ4zRxQn/H3Sw9z0MDd9zE4fj5n19XV2SV2yTvYihIDL5bK6GUSWMAwDxcXFVjeDKCHw90kPc9PD3PQxOz08ZtZnRXacIY9EiL79SjBlZWUQQuCTTz4BALzzzjsQQmD//v09etx4lnxddtllmDNnTkz3EULglVde6fFzE+kIXjyEswREPcffJz3MTQ9z08fs9MR6zNxbx+7x1FfH7lacYsIBuU3t3r0b1157LY466ii4XC4UFRXhzDPPxNtvv21101BUVITq6mqMHTs2bo955513YsKECXH7zMkHH3wQK1eujOk+1dXVmD17dlyenyhWSilUV1fzoIQoDvj7pIe56WFu+hIpu74+do/lmLm3jt2PP/74uD1eXx679/Vn3LNk3YbKysowZcoU9O/fH0uXLsVxxx2HtrY2vPHGG5g/fz4+//xzS9vncDiQn5/fK4/dXQlJ8GMKuuPxeGJ+7t7qE1E0DMPAsGHDrG4GUULg75Me5qaHuelLlOz6+tg91rLr3jx2786RduzOknWKytVXXw0hBD744APMnTsXxxxzDI499ljccMMNeP/99831KioqcPbZZ6Nfv37IysrCBRdcgJqaGvPnwXeu/vjHP2Lo0KHo168frr76agQCASxZsgT5+fnIzc3FPffcE/L8QgisWLECs2fPRnp6Oo466ii8+OKL5s8PL3uJ5L333sMpp5yC9PR0FBUV4brrrkNTU1PEdVeuXIm77roLW7ZsgRACQgjzHbJgW8466yy43W7cc889CAQCuOKKK1BSUoL09HSMHDkSDz74YMhjHl72cuqpp+K6667DwoULkZOTg/z8fNx5551h/Q6WvQT7+NJLL+G0005DRkYGxo8fjw0bNoTc57HHHjM/Vu+cc87BsmXL0L9//05zIeqMUgotLS0JMUtAZDX+PulhbnqYm75us1MKaGqy5iuG17Ovj93vvvvukLJrHrtHf+z++9//vu+P3VWC83q9CoDyer1hPzt48KDatm2bOnjwYOgP2n/F+u4rBnv37lVCCHXvvfd2uV4gEFDHH3+8Ovnkk9WHH36o3n//fTVx4kQ1bdo0c5077rhD9evXT5133nnq3//+t3rttddUamqqmjVrlrr22mvV559/rv74xz8qAOr999/vEA/UgAED1GOPPaa2b9+ubrvtNuVwONS2bduUUkrt3LlTAVAff/yxUkqpNWvWKABq3759SimlvvrqK+V2u9UDDzygvvjiC/XPf/5TTZgwQV122WUR+9Lc3KxuvPFGdeyxx6ry8nL1zTffqObmZrMtubm56o9//KPasWOHKi8vV62trWrRokVq06ZN6uuvv1Z/+tOfVEZGhnruuefMx7z00kvV2WefbX4/bdo0lZWVpe688071xRdfqCeeeEIJIdSqVatC+v3yyy+H9HHUqFHq9ddfV9u3b1fnnXeeGjZsmGpra1NKKfXee+8pwzDU0qVL1fbt29UjjzyicnJylMfj6fR163SbpKQXCARURUWFCgQCVjeF4qCrfRPFLtY8+fukh7npYW76Ds8u7DipsbHvj9uDX42NUfXBqmP3d999V0kplVLWHrtXV1er6upqWx27L168WH3++ec9PnaPdt/EAbnNBuQbN25UANRLL73U5XqrVq1SDodDVVRUmLf9+9//VgDUBx98oJRq/6XOyMhQDQ0N5jqzZs1SxcXFITuNkSNHqsWLF3eIB+onP/lJyPOVlpaqn/70p0qp7n+pr7jiCjVv3ryQ+7/77rvKMIxOB6J33HGHGj9+fNjtANSCBQu6zEIppebPn6/mzp1rfh/pl/rkk08Ouc+JJ56obr755pDnOvyX+g9/+IP582C+n332mVJKqR/84Afqe9/7XshjXnTRRRyQExEH5HHGPImSgx0H5Dx2D5VMx+7R7ptYsm4z7dtW9z777DMUFRWhqKjIvG3MmDHo378/PvvsM/O24uJiZGZmmt/n5eVhzJgxIR9yn5eXhz179oQ8/qRJk8K+7/i4XdmyZQtWrlyJfv36mV+zZs2ClBI7d+7s8r6Rrnp4wgknhK33yCOPYOLEiRg0aBD69euH3//+96ioqOjysceNGxfyfUFBQVi/u7pPQUEBAJj32b59O0466aSQ9Q//nihaSikcPHgw6r8BRNS5Ln+fNm0CXnwR+Oqrvm/YEY5/h/QwN33dZpeRATQ2WvOVkRF1H6IR72P3mpqakOe26tg9kiP52P3EE08MGW/0xbE7L+pmMyNGjIAQIm4Xfzj8IgpCiIi3SSnj8nwA0NjYiKuuugrXXXdd2M+GDh3a5X39fn9Y+9xud8j3zz77LG666Sb8+te/xqRJk5CZmYmlS5di48aNXT62Tr873kcc+gi7eGZFFKSUQn19PQoKCsxtjYj0dPn7dP/9wPPPAw8+CETYTyUz/h3Sw9z0dZudEMBhx4FHGquO3f1+f1yeD+jZsXskR/qxe6TxRm/iDLnN5OTkYNasWXjkkUciXkgh+HmBo0ePRmVlJSorK82fbdu2Dfv378eYMWN63I6OF6AIfj969Oio7vutb30L27Ztw9FHHx32lZqaGvE+qampCAQCSE1N7XZn9s9//hOTJ0/G1VdfjQkTJuDoo4/Gjh07outYHI0cORKbNm0Kue3w74miZRgGCgsLQ94BJyI9Xf4+BQ/C+vhjb+yAf4f0MDd9iZCdVcfuDocj5JjZqmP3aBxJx+4ffvhhyHijL47dOUNuQ4888gimTJmCk046Cb/85S8xbtw4+P1+vPnmm1ixYgU+++wzzJgxA8cddxwuuugiLF++HH6/H1dffTWmTZsWsUwkVi+88AJOOOEEnHzyyfjzn/+MDz74AP/3f/8X1X1vvvlmfPvb38Y111yDK6+8Em63G9u2bcObb76J3/zmNxHvU1xcjJ07d2Lz5s0YOnQosrKyOv1IghEjRuDJJ5/EG2+8gZKSEjz11FPYtGkTSkpKtPur49prr8XUqVOxbNkynHnmmVi9ejX+/ve/2/rdcXGXfdtudwICuam52NO6Bwose7SCuoO5JwqlFJqbm5GRkRH+Nzk4II/j7FKi6DI36hRz05co2Vlx7K7arxVm5mbVsfsnn3yCIUOGIDMz0zbH7vfffz/OOussrFmzpk+O3e37dlNv6uvLQsToqKOOwkcffYTTTjsNN954I8aOHYvvfOc7ePvtt7FixQoA7SUYr776KrKzszF16lTMmDEDRx11FJ577rm4RHTXXXfh2Wefxbhx4/Dkk0/imWeeifrdu3HjxmHt2rX44osvcMopp2DChAlYtGgRBg8e3Ol95s6dizPOOAMzZsxAbm4unnnmmU7Xveqqq3DuuefiBz/4AUpLS7F3715cffXVMfexp6ZMmYJHH30Uy5Ytw/jx4/GPf/wD119/PdLS0vq8LWR/AgLF6cUQsO8BCdGRQimFhoaGyOd2Og/NVXCGPEyXuVGnmJu+RMnOimP3w8uwrTp2P+200zBo0CDbHLuvWLECy5cvx/HHH99nx+5C2X0L70ZDQwM8Hg+8Xi+ysrJCftbS0oKdO3eipKSEg6QYCCHw8ssvh3wWIEXnxz/+MT7//HO8++67EX9+pG+TnCGnZBbPGfKu9k0Uu7jmefXVwIoVwKJFwF13xaeBRBQXR/px0pGKx+76enLsHu2+iTPkZBtKKQQCAVu9S3r//fdjy5Yt+Oqrr/Dwww/jiSeewKWXXmp1s8iGBAQKXYWcISeKA6UUDhw4EHl/wnPIO9VlbtQp5qaP2emx4zHzkWLp0qX46KOP8OWXX/bZsTvPISdbkVLa6sIeH3zwAZYsWYIDBw7gqKOOwkMPPYQrr7zS6maRDQkI5Kfmo9pXzXPIiXooeF6q2+3u/BxyDsjDdJkbdYq56WN2+ux2zHyk2LRpE5YuXdqnx+4ckFPMrHq3LdLHOhzpnn/+eaubQAlCQmLzgc1WN4MoIRiGgby8vMg/DJ5Dzou6hekyN+oUc9PH7PQcfszMmfLoWXHszrdNyDaUUvD7/fyjQknJgIFhacNg8M82UY8ppeD1elmyHqMuc6NOMTd9zE4Pj5n1WZEdj+zIVviHhZKZx+mxuglECUEpBZ/PxwF5jLrMjTrF3PQxO33MTF9fZ8eSdbINO5asE8WLhMSnjZ9a3QyihGAYBnJzcyP/kAPyTnWZG3WKueljdnp4zKzPiuw4Q062wfIbSmYGDAxPH86SdaI4UEph//79Xc+Q8xzyMF3mRp1ibvqYnR4eM+tjyTpRN/iHhZKZy3BZ3QSimC1evBgnnngiMjMzkZubizlz5mD79u0h65x66qkQQoR8/eQnP+m1NnV5wBW8qBtnyMPwIF8Pc9PH7PQxM319nR0H5GQbwRISfuwFJSMJiW1N2yAhrW4KUUzWrl2L+fPn4/3338ebb76JtrY2zJw5E01NTSHr/fjHP0Z1dbX5tWTJkl5rk2EYGDhwYOSPBGLJeqe6zI06xdz0MTs9PGbWZ0V2PIc8AnFX32686o7kfgfrzjvvxCuvvIJPPvmky/WUUggEAnA4HCgpKcGCBQuwYMGCPmkjkdUMGBiRMQJfNn/JQTnZyj/+8Y+Q71euXInc3Fxs3rwZU6dONW/PyMhAfn5+n7RJKYV9+/YhOzubn0Megy5zo04xN33MTk/HY+beyC3aY/eOiouLbXHs3tvZRcK3m2zosssuCyvtE0Lgq6++6tHjvvPOOxBCYP/+/V2ut3LlSvTv379Hz9XRTTfdhLfffjum+2zatAnz5s2LWxuIiKhveL1eAEBOTk7I7X/+858xcOBAjB07Frfeeiuam5s7fQyfz4eGhoaQLwCQsv3NKqWUWXIopYy43Ok6Dkf7k7S1dXrfw5eDj9fby9G0JV7L7FN8+9RbfU3G1ylSpkf6clfH7j157DVr1pjH7h1v70gphccffxz9+/ePW59uvPFGvP322zHdb9OmTfjxj398RLwenS13zEz3MSJtt93hgNymzjjjjJDSvurqapSUlFjdrBCtra1RrdevXz8MGDCg2/WEEHA6nRBCYNCgQcjIyOhpE4lsQ0Jie/N2zo6TrUkpsWDBAkyZMgVjx441b//hD3+IP/3pT1izZg1uvfVWPPXUU7j44os7fZzFixfD4/GYX0VFRQCAffv2mf8Hl+vr6803Aerq6tDQ0AAhBPx+v1k2X1NTY74BsL+xsf1J/H5UVVXB5/MBACorK9F2aNa8oqICgUAAUkpUVFRASolAIICKigoAQFtbGyorKwG0v3lQVVUFAGhpaUF1dTUAoLm5GTU1NQCAxsZG1NbWAgAaGhpQV1cHoP3Ni/r6+qj6BAC1tbVoPNT+jn2qrq5GS0sLAPSoT7t27UJOTg5aW1sTpk998ToJIRAIBHDgwIGE6VNfvU5CCGRmZmLXrl0A2o8tA4EAgPYBT/AxpJQhy/5DF2UMBAKdLgcfx+/3d7ocHFC1HXqDLrgcHIB1XG5tbQ1ZDrYxuHzGGWegrKwM1dXVqKqqQllZGUpKSkL6EWufOg74Du8TAPNvXXC97vrU2toaVZ9SU1PNN1Uj9TVSnwYNGoS0tLQj+nXq+MaQEKLbPgXXDT7n4b9Pe/fuRTQ4ILcpl8uF/Pz8kC+Hw4Fly5bhuOOOg9vtRlFREa6++mrzDyQAlJeX48wzz0R2djbcbjeOPfZY/O1vf0NZWRlOO+00ADDLgi677LKw533nnXdw+eWXmzsYIQTuvPNOAO2lKL/61a9wySWXICsry5zBvvnmm3HMMccgIyMDRx11FG6//XZzIwbay16OP/548/vLLrsMc+bMwf3334+CggIMGDAA8+fPD/kjUVxcjOXLl5v3EULgD3/4A8455xxkZGRgxIgReO2110La/tprr2HEiBFIS0vDaaedhieeeCKqigCiI4EBA2PcY3iVdbK1+fPn41//+heeffbZkNvnzZuHWbNm4bjjjsNFF12EJ598Ei+//DJ27NgR8XFuvfVWeL1e8ys4AMnOzjb/Dy7n5OTA4/EAAAYOHIisrCxIKWEYhvnGbl5enrncf9Cg9idpa0NhYSFcrvaLKRYVFZkfhTN06FA4HA4YhoGhQ4fCMAw4HA4MHToUAJCSkmK+SeByuVBYWAgASEtLQ0FBAYD2Ev28vDwA7W9MDzr0vFlZWRg4cCAAwOPxmAe93fUJAAYNGoR+/fqF9amgoABpaWkA0KM+FRYWoq6uzlxOhD71xesUPLgP9iMR+tRXr5OUEl6v1+xHamoqHIeqWIITNU2tTTjoP4hW1Wou+6QPTa1NaAm0dLrcEmhBU2sTfNLX6fJB/0E0tTahVbWGLDe3NUMpFXKucWpqashysI3BZZfLhaFDhyI/Px8FBQVmvx944AFMnDgRbrcbw4YNw//8z/+gsbERhmEgJSUF5eXlmDNnDnJzc+F2uzF+/HisWrUKZWVlmDFjhvkapaSk4MorrwQAOJ1Oc+b2vffew5VXXgmv14vU1FQ4nU7ceeedSElJwfDhw/GrX/0KV155Jfr374958+YhJSUFt9xyC4455hhkZ2fj6KOPxu233272TQiBe++9FxMmTDD7etlll+Hcc8/FQw89hIKCAgwaNAgLFixAW1ubeU52cXExHnroIfN1dzqdWLlyJc455xxkZWVhzJgxeO211+BwOOA8dHHN//f//h9Gjx6NtLQ0zJw5E3/6058ghEBjY6O5HTidTvMaAykpKSHLwTZH+zoFbzcMA0qpkNev48ehdVw2DMN8zsN/n6KZcAR4DnnCMQwDDz30EEpKSvD111/j6quvxsKFC/Hb3/4WAMyB7bp16+B2u7Ft2zb069cPRUVF+Mtf/oK5c+di+/btyMrKQnp6etjjT548GcuXL8eiRYvMq+QG/wADwP33349FixbhjjvuMG/LzMzEypUrMXjwYGzduhU//vGPkZmZiYULF3bajzVr1qCgoABr1qzBV199hR/84AcYP348fvSjH3V6n7vuugtLlizB0qVL8fDDD+Oiiy5CeXk5cnJysHPnTpx33nn4n//5H1x55ZX4+OOPcdNNN8WcL5GVfNJndROItF1zzTV4/fXXsW7dOgwZMqTLdUtLSwEAX331FYYPHx72c5fLZR7YdxQ8KOp43l/Hi0F1XO544BayTvBx29o6vW+k5eCb1L25HG1b4rV8+PMHD5QNw0iYPvXV69Tp9mbjPvXF6xQc9HYchHdsV3NbM/ot/s9xaF9qvLUR7lS3+X3HnLpb7nibw+GI+dg9MzOz22P34HNMmTIl4rF78OeHH7sLIZCVldXlsXukfkQ6dp8wYQJ+/OMfh7Sp431++ctfdnnsfv7550c8du9s+4z3crTrdvZ7E+3FCDkgt6nXX389ZCA8e/ZsvPDCCyEXSiguLsbdd9+Nn/zkJ+YvdUVFBebOnYvjjjsOAHDUUUeZ6wffCc3Nze30HPHU1FR4PB4IISJefGf69Om48cYbQ2677bbbQtp000034dlnn+1yQJ6dnY3f/OY3cDgcGDVqFL73ve9h9erVXZ43ftlll+G//uu/AAD33nsvHnroIXzwwQc444wz8Lvf/Q4jR47E0qVLAQAjR47Ev/71L9xzzz2dPh7RkURCYsfByLOFREcypRSuvfZavPzyy3jnnXeiOr0qeKGg4IxevAkhOr8WCi/q1qkuc6NOMTd9iZRdXx67B6sHAGuP3d9+++2QAfnhjsRj947Z9RUOyG3qtNNOw4oVK8zv3e72d+jeeustLF68GJ9//jkaGhrg9/vR0tKC5uZmZGRk4LrrrsNPf/pTrFq1CjNmzMDcuXMxbty4uLXrhBNOCLvtueeew0MPPYQdO3agsbERfr/fLHHqzLHHHmu+Gwq0H5Rt3boVbW1tnf6SdOyH2+1GVlYW9uzZAwDYvn07TjzxxJD1TzrppKj7RWQ1AwbG9huLfzX+i+eRk63Mnz8fTz/9NF599VVkZmZi9+7dANpLYtPT07Fjxw48/fTT+O53v4sBAwbg008/xfXXX4+pU6fGdf/UkZQSdXV1kT9OKTggP3QOI/1Hl7lRp5ibvu6yy0jJQOOtjRHu2fsyUmK7llFfHrsr1f757cFrL3Wlt4/du3IkHrvHkl288K+CTbndbhx99NHmV0FBAcrKyvD9738f48aNw1/+8hds3rwZjzzyCID/XLTgyiuvxNdff43//u//xtatW3HCCSfg4Ycfjmu7OtqwYQMuuugifPe738Xrr7+Ojz/+GL/4xS+6veBb8LyMICGEeQ5WrPchShRev9fqJhDFbMWKFfB6vTj11FNRUFBgfj333HMA2mdv3nrrLcycOROjRo3CjTfeiLlz5+Kvf/1rr7VJCAGXyxV5nxJ805cz5GG6zI06xdz0dZedEALuVLclX7G+nn197B5t+3r72D3e9+kLff27yhnyBLJ582ZIKfHrX//afBfx+eefD1uvqKgIP/nJT/CTn/wEt956Kx577DFce+215kULglct7Exqamq36wStX78ew4YNwy9+8QvztvLy8mi7FEa3hGTkyJH429/+FnLbpk2btNtB1NckJMpb9H93iKwS6WN4OioqKsLatWv7qDXthBDmhanCsGS9U13mRp1ibvoSPbveOnY/vOzaymN3XVYdu1tRss4Z8gRy9NFHo62tDQ8//DC+/vprPPXUU3j00UdD1lmwYAHeeOMN7Ny5Ex999BHWrFmD0aNHAwCGDRsGIQRef/31kI+vOFxxcTEaGxvx9ttvo66ursvPih0xYgQqKirw7LPPYseOHXjooYfw8ssva/ex48cWxOKqq67C559/jptvvhlffPEFnn/+eaxcuRJA378LRqTDgIGJmRN5lXWiOJBSoqamJvJMDAfkneoyN+oUc9OX6Nn11rF78GO5gsfMVh6767Lq2P3w7PoCj+wiUHeoPv2Kl/Hjx2PZsmW47777MHbsWPz5z3/G4sWLQ9YJBAKYP38+Ro8ejTPOOAPHHHOMedGIwsJC3HXXXbjllluQl5eHa665JuLzTJ48GT/5yU/wgx/8AIMGDcKSJUs6bdNZZ52F66+/Htdccw2OP/54rF+/Hrfffrt2H3XPvSopKcGLL76Il156CePGjcOKFSvMd/4iXamX6EijoLC7dTcU+m4HQZSohBDIyMiIfFDHAXmnusyNOsXc9CV6dr157N7xmNnKY3ddVh679/W1HoTqy+G/BRoaGuDxeOD1esMuRtDS0oKdO3eipKTE/IxESh733HMPHn30UfPza48ER/o2Ke5KzB0iUTTi+QZqV/smil1c8/zoI2DiRGDwYKCqKj4NJKK4ONKPk6h32e3YPdp9E2fIyTaUUmhtbdUuIfntb3+LTZs2mSVBS5cuxaWXXhrnVhL1DgMGSj2lLFknigMpJaqrq1myHqMuc6NOMTd9zE5PT4+ZjxRWHLtbkR0v6ka20vHjFGL15Zdf4u6770Z9fT2GDh2KG2+8EbfeemscW0fUexQUyg6WsWSdKA6EEMjKymLJeoy6zI06xdz0MTt9PTlmPlJYdeze19lxQE62IYTo0S/IAw88gAceeCCOLSLqOwoKNa01VjeDKCEIIcI+6sfEAXmnusyNOsXc9DE7PT09Zj5SWHHsbkV2rH0k20iU8hsiHQ44MNkzGQ7YfwdLZDUpJaqqqrouWff7+7ZRNtBlbtQp5qaP2enhMbM+K7KzdEAeCARw++23o6SkBOnp6Rg+fDh+9atfhQSglMKiRYtQUFCA9PR0zJgxA19++WVc28GN1T76+nMB+xq3ReqMhMT25u2Q4EEJUU8JIZCTkxO5DDa4n+EMeZguc6NOMTd9nWXH46XuJfoxc2+KJbt4bIuWDsjvu+8+rFixAr/5zW/w2Wef4b777sOSJUvw8MMPm+ssWbIEDz30EB599FFs3LgRbrcbs2bNQktLS4+fP+XQu+BdfRYfHTmEEDAMI6F3aMFtMbhtEgUpKOxt28tzyIniQAiB9PT0rs8hl7L9i0xd5kadYm76Ds8uWErc2tpqZbOOeMlwzNxbYs0uHsfulr51sn79epx99tn43ve+B6D9Q+ufeeYZfPDBBwDa33FYvnw5brvtNpx99tkAgCeffBJ5eXl45ZVXcOGFF/bo+R0OB/r37489e/YAQEJ/zmEiUEqhra0NKSkpCfc6KaXQ3NyMPXv2oH///glx3g/FlwMOTMmegn/u+ycCCFjdHCJbC5bBFhYWhn/ebMeDqrY2oJc/79ZOusyNOsXc9B2endPpREZGBmpra5GSksI8O5HIx8y9Ldrs4nnsbumAfPLkyfj973+PL774Ascccwy2bNmC9957D8uWLQMA7Ny5E7t378aMGTPM+3g8HpSWlmLDhg0RB+Q+nw8+n8/8vqGhAQDMc0+CZQVCCEgpkZeXBwCoqakxQ1dK2W456EhoS2/2SUoJIQSEEEdEG+P9Onk8HnOb7NhXnWXDMKCUglIqbssAzI/dkpBRL6tD/zouO+CAhAxbdgon/Kr93M1YlgUEDBgIIBC2LCAgIUOWdfphZZ8UFP514F9h/bBzn+z2OsXz94nnQ1pLCIFBgwZ1PUMOcEB+mC5zo04xN32HZyeEQEFBAXbu3Iny8nKLW3dki3T8SdGJJbv+/fsjPz+/R89n6YD8lltuQUNDA0aNGgWHw4FAIIB77rkHF110EQBg9+7dAGAOUILy8vLMnx1u8eLFuOuuu8Ju37dvH/r37499+/YBAHJyclBfXw+n04mCggLzinqZmZmoq6tDeno63G439uzZg379+iEjIwM1NTXweDxIS0tDdXU1cnJy4HK5UFVVhUGDBiE1NRVVVVXIy8uDYRiorq5GQUEBpJSoqalBYWEhWltbUVtbi8LCQvh8PtTX16OgoAAtLS3wer3Iy8tDc3MzGhsbkZubi6amJhw8eBADBw7EgQMH0NraigEDBqChoQGBQADZ2dnYv38/AJj9czgcyMrKwt69e5Gamso+2aRPOTk5qKurQ1NTEzIzM1FTU4OsrCy43W6zH+np6WY/0tLSUFlZiYKCAqSmpqKiogJDhgyBYRioqKjA0KFDIaXErl27UFxcjLa2NlRXV2PYsGHw+Xyora1FUVERWlpaUF9fj8LCQjQ3N6OhoQEFBQVobGxEc3Mz8vLy0NDQYL7RVZJeApfhwrambRiRMQIAsL15O0a5R8EnfdhxcAfG9hsLr9+L8pZyTMicgN2tu1Hlq8KJnhNRdrAMNa01KPWUYnvzduxt24sp2VOw5cAWeP1eTM2eio3ejWgKNGF6znSs3bcWARXA9JzpWF2/Gg7hwLTsaVi1dxXcDjdKPaVYXb8aWc4sjM8cj3X71iEnJQcjM0ZivXc9clNzUZxejI3ejRjsGoz81HxsPrAZRWlF8Dg9+LTxU1v0KTsl2+xTXmpeQvTJbq9TIBCI2+/T3r17Y95nUvwIIZCWlhb5hx3PHeSF3UJ0mRt1irnpi5RdamoqRowYwbJ1slxKSkpcqlqFsvCqCM8++yx+9rOfYenSpTj22GPxySefYMGCBVi2bBkuvfRSrF+/HlOmTME333yDgoIC834XXHABhBB47rnnwh4z0gx5UVGROSA/fIa8JzOQVs1SRlpOhj4ppVBRUYGioiI4HI6E6JPdXifHrxyWz1J2tmznmddo+pQiUjAtexre2fcOAiqQEH2y2+skF8m4/T55vV5kZ2fD6/UiKysL1DMNDQ3weDxR5ymlRGVlJYqKisJLXqUEggdYe/YAgwb1QovtqcvcqFPMTR+z08Pc9MUzu2j3TZbOkP/sZz/DLbfcYpaeH3fccSgvL8fixYtx6aWXmtP/NTU1IQPympoaHH/88REf0+VywRWhvCwYaMfyg44h9+ZycJDUm8vJ0qfBgweb3ydKn+z2OnW8yndPljueB91xOTgIinVZQZmPc/hy8EJoHZfj1Y++6lObasMG74aQn9m9T3Z7neL5+8QDJGsJIczquDCG0f4lJa+0fpguc6NOMTd9zE4Pc9NnRXaWHhE0NzeHHZQEZz4BoKSkBPn5+Xj77bfNnzc0NGDjxo2YNGlSn7aVrCeEQGpqKv+4UNJqCjRZ3QSihNDt/iR4HjkH5CG4H9bD3PQxOz3MTZ8V2Vk6ID/zzDNxzz334P/9v/+HsrIyvPzyy1i2bBnOOeccAO2BLFiwAHfffTdee+01bN26FZdccgkGDx6MOXPmWNl0soCUEmVlZbwYEiUlp3Bi5oCZcAp+rihRT3W7PwkOyHkOeQjuh/UwN33MTg9z02dFdpYe2T388MO4/fbbcfXVV2PPnj0YPHgwrrrqKixatMhcZ+HChWhqasK8efOwf/9+nHzyyfjHP/7Bi2MkISEEhgwZwnf7KCn5lR9r960NKaUmIj3d7k+CF3bjDHkI7of1MDd9zE4Pc9NnRXaWXtStL8R6oRc6sgUvVkbWEHfxD7uVOl5ojPqeuiN+u0vum+JLJ88u9ye5uUBtLfDpp8Bxx8WxpfbH/bAe5qaP2elhbvrilV20+ya+SmQbUkpUVFSw/IaSklM4MT1nOkvWieKg2/0JzyGPiPthPcxNH7PTw9z0WZEdB+RkG4ZhYOjQoXy3j5KSX/mxun41Z8iJ4qDb/QkH5BFxP6yHueljdnqYmz4rsuOrRLahlIKUEgl+lgVRpxzCYXUTiBJCt/sTXtQtIu6H9TA3fcxOD3PTZ0V2HJCTbSilsGvXLv5xoaTkFE5My57GknWiOOh2f8KLukXE/bAe5qaP2elhbvqsyI5HdrHi1QotYwAotroRye5OqxuQvPzKj1V7V1ndDKKEYBgGiouLO1+BJesRdZsbRcTc9DE7PcxNnxXZcYacbEMBaHW7wff6KFm5HW6rm0CUEJRSaG1t7b5knQPyEN3mRhExN33MTg9z02dFdhyQk20opxPVpaVQThZ2UPJxCidKPaUsWSeKA6UUqqureQ55jLrNjSJibvqYnR7mps+K7HhkR7Zh+P0Ytnq11c0gskTwKutE1HOGYWDYsGGdr8BzyCPqNjeKiLnpY3Z6mJs+K7LjDDnZhhICLR4PFM/jpyQkIOBxeiDA7Z+op5RSaGlpYcl6jLrNjSJibvqYnR7mps+K7DggJ9tQhoHa8eOh+JmKlIQMGBifOR4G/2wT9ZhSCrW1tRyQx6jb3Cgi5qaP2elhbvqsyI4l62QbRiCAonXrrG4GkSUCCGDdPm7/RPFgGAaKioo6X4ED8oi6zY0iYm76mJ0e5qbPiuw41UK2oYTAwQEDWLJOSUlAYEDKAJasE8WBUgoHDx7kRd1i1G1uFBFz08fs9DA3fVZkxwE52YYyDNSPHMmSdUpKBgyMzBjJknWiOFBKob6+vvMDLl7ULaJuc6OImJs+ZqeHuemzIjuWrJNtGIEACtevt7oZRJYIIID1Xm7/RPFgGAYKCws7X4El6xF1mxtFxNz0MTs9zE2fFdlxqoVsQwmBprw8lqxTUhIQyEvNY8k6URwopdDU1MSLusWo29woIuamj9npYW76rMiOA3KyDSUEGoqLOSCnpCQgUJxezAE5URwopdDQ0MBzyGPUbW4UEXPTx+z0MDd9VmTHknWyDUNKFGzcaHUziCwhIbHRy+2fKB4Mw0BBQUHnK/Ac8oi6zY0iYm76mJ0e5qbPiuw4Q062oYTAgcJCzpBTUhIQKHQVcoacKA6UUjhw4ABL1mPUbW4UEXPTx+z0MDd9VmTHATnZhhICzfn5HJBTUhIQyE/N54CcKA6UUmhubuaAPEbd5kYRMTd9zE4Pc9NnRXYsWSfbMKRE3ubNVjeDyBISEpsPcPsnigfDMJCXl9f5ChyQR9RtbhQRc9PH7PQwN31WZMcZcrINZRjwDhvGzyGnpGTAwLC0YfwccqI4UErB6/Xyom4x6jY3ioi56WN2epibPiuy45Ed2YYC4PN4wD8tlKw8To/VTSBKCEop+Hy+zg+4eFG3iLrNjSJibvqYnR7mps+K7FiyTrZhSIncTz+1uhlElpCQ+LSR2z9RPBiGgdzc3M5XYMl6RN3mRhExN33MTg9z02dFdpwhJ9tQhoH9w4ezZJ2SkgEDw9OHs2SdKA6UUti/fz8v6hajbnOjiJibPmanh7npsyI7HtmRbSgAfpeLJeuUtFyGy+omECUEpRT8fj/PIY9Rt7lRRMxNH7PTw9z0WZEdS9bJNgwpMXDbNqubQWQJCYltTdz+ieLBMAwMHDiw8xV4DnlE3eZGETE3fcxOD3PTZ0V2nCEn21CGgfqRI1myTknJgIGRGSNZsk4UB0op1NfXs2Q9Rt3mRhExN33MTg9z02dFdjyyIyIiIuqIA3IiIuojLFkn2xBSImf7dqubQWQJCYntzdz+ieJBCIGcnJzOV+CAPKJuc6OImJs+ZqeHuemzIjvOkJNtSMNA3ZgxkCxZpyRkwMAY9xiWrBPFgZQSdXV1kFJGXoEXdYuo29woIuamj9npYW76rMiOR3ZkGwKA0+eDsLohRBbxSZ/VTSBKCEIIOJ1OCNHJHoUXdYuo29woIuamj9npYW76rMiOJetkG0JK9N+xw+pmEFlCQmLHQW7/RPEghED//v07X4El6xF1mxtFxNz0MTs9zE2fFdlxhpxsQxoG9owbx5J1SkoGDIzrN44l60RxIKXEnj17ui9Z54A8RLe5UUTMTR+z08Pc9FmRHY/syDYEAJfXy5J1Slpev9fqJhAlBCEEXC5X5yWJHJBH1G1uFBFz08fs9DA3fVZkx5J1sg0hJTzl5VY3g8gSEhLlLdz+ieJBCAGPx9P5CryoW0Td5kYRMTd9zE4Pc9NnRXacISfbkIaBmokTWbJOScmAgYmZE1myThQHUkrU1NR0XpLIi7pF1G1uFBFz08fs9DA3fVZkxyM7sg2hFDJ274ZQyuqmEPU5BYXdrbuhwO2fqKeEEMjIyGDJeoy6zY0iYm76mJ0e5qbPiuxYsk62IZRCZlWV1c0gsoSCQpWP2z9RPAghkJmZ2fkKHJBH1G1uFBFz08fs9DA3fVZkxxlysg1pGKguLWXJOiUlAwZKPaUsWSeKAyklqquru7/KOs8hD9FtbhQRc9PH7PQwN31WZMcjO7INoRSyyspYsk5JSUGh7GAZS9aJ4kAIgaysrM5LEnkOeUTd5kYRMTd9zE4Pc9NnRXYsWSfbEErBXVNjdTOILKGgUNPK7Z8oHoQQcLvdna/AkvWIus2NImJu+pidHuamz4rsOENOtiEdDlRNngzpcFjdFKI+54ADkz2T4QC3f6KeklKiqqqq+5J1DshDdJsbRcTc9DE7PcxNnxXZcUBOtiGkRM727RD840JJSEJie/N2SHD7J+opIQRycnJ4lfUYdZsbRcTc9DE7PcxNnxXZsWSdbEMohfS9e61uBpElFBT2tnH7J4oHIQTS09M7X6HjRd2UAnhQCyCK3Cgi5qaP2elhbvqsyI4z5GQb0uFA5dSpLFmnpOSAA1Ozp7JknSgOpJSorKzsvCTR2WG+IhDom0bZQLe5UUTMTR+z08Pc9FmRHQfkZBtCSgzasoUl65SUJCS2HNjCknWiOBBCYNCgQd2XrAMsW++g29woIuamj9npYW76rMiOJetkG0IppHm9VjeDyBIKCl4/t3+ieBBCIC0trfMVDh+Qs/QTQBS5UUTMTR+z08Pc9FmRHWfIyTak04ny6dMhnXwfiZKPUzgxPWc6nILbP1FPSSlRXl7e/VXWgfbzyAlAFLlRRMxNH7PTw9z0WZEdB+RkG8LvR8HGjRA8OKIk5Fd+bPRuhF9x+yfqKSEECgoKOi9J7HitEpasm7rNjSJibvqYnR7mps+K7DjVQrYhAKQ2NVndDCLLNAW4/RPFgxACqampXa3QfmE3v58D8g66zY0iYm76mJ0e5qbPiuw4Q062IZ1OlM2cyZJ1SkpO4cTMATNZsk4UB1JKlJWVdV2SyM8iDxNVbhSGueljdnqYmz4rsuOAnGxD+P0YsnYtS9YpKfmVH2v3rWXJOlEcCCEwZMiQrksSOSAPE1VuFIa56WN2epibPiuy44CcbEMAMAIB8E8LJauA4uchE8WDEAKGYUQ3IOebwKaocqMwzE0fs9PD3PRZkR0H5GQb0ulEBa+yTkmKV1knih8pJSoqKrouSQzuazhDbooqNwrD3PQxOz3MTZ8V2XFATrZh+P0Yuno1DM5WUBLyKz9W169myTpRHBiGgaFDh8IwujgMYsl6mKhyozDMTR+z08Pc9FmRHV8lsg0FQDocUFY3hMgiDuHofiWiI8zixYtx4oknIjMzE7m5uZgzZw62b98esk5LSwvmz5+PAQMGoF+/fpg7dy5qamp6rU1KKUgpoVQXexQOyMNElRuFYW76mJ0e5qbPiuw4ICfbUE4ndk2bBsWSdUpCTuHEtOxpLFkn21m7di3mz5+P999/H2+++Sba2towc+ZMNHX4GMvrr78ef/3rX/HCCy9g7dq1+Oabb3Duuef2WpuUUti1a1d0A3JWZZmiyo3CMDd9zE4Pc9NnRXZCJfgr1dDQAI/HA6/Xi6ysrJ4/IC+OQElM3Gl1C4iso+6I3+4y7vsmG6mtrUVubi7Wrl2LqVOnwuv1YtCgQXj66adx3nnnAQA+//xzjB49Ghs2bMC3v/3tbh+zV/I89lhg2zbg7beB6dPj85hERJQ0ot03cYacbEMBaHW7WbJOScvtcFvdBKIe83q9AICcnBwAwObNm9HW1oYZM2aY64waNQpDhw7Fhg0bIj6Gz+dDQ0NDyBcA8yI8SilzdqNj6WFwWSmFlpYWc/1I6wRnyFVra+frHPacvb3cVZ/ivRzp+QOBAFpbWyGlTJg+9cXrFNX2ZrM+9dXrpJSCz+dDIBBImD71xesUCATg8/nCyq/t3Ke+ep2klGhpaTGfOx796A4H5GQbyulEdWkpS9YpKTmFE6WeUpask61JKbFgwQJMmTIFY8eOBQDs3r0bqamp6N+/f8i6eXl52L17d8THWbx4MTwej/lVVFQEANi3b5/5f3C5vr7efBOgrq4ODQ0NUErhyy+/xIEDBwAANTU1aG5uBgBUV1ejpaXFHJC3Hbq9srISbYfOJ6+oqEAgEICU/7kabyAQQEVFRft92tpQWVkJoP3Ng6qqKgDt58pXV1cDAJqbm83z5BsbG1FbWwugfUalrq4OQPubF/X19VH1CWivPmhsbOy8TwCqqqrg8/m0+1RdXZ1wfert10kpha+++iqh+tRXr5NS7eXDidSnvnqdvv76ayilEqpPffE6+f1+/Pvf/4ZSqsd92rt3L6LBkvVYsWSdkhhL1imZsWS9537605/i73//O9577z0MGTIEAPD000/j8ssvNw+Wgk466SScdtppuO+++8Iex+fzhazf0NCAoqIi7Nu3D/379zdnPIQQkFJCCBH78pQpwIYNUH/5C8S553a5vmEY5mxKby73uE8xLLNP7BP7xD6xTz1b9nq9yM7O7nZfz6kWsg0lBHxZWXA1NECohH4fiSiMgECWMwsN/gYonrhBNnTNNdfg9ddfx7p168zBOADk5+ejtbUV+/fvD5klr6mpQX5+fsTHcrlccLlcYbcHP6ZGCBF2W8dlpRRaW1vNx4i0TnCGXBwqlY24zmHPGXze3lru6vl7YznS87e0tMDlcsWt31b3qS9ep6i2N5v1qbeXg8+vVHvJejC7ROhTby4HCSHM3BKlT331OgEwf1972vaOj9kVlqyTbSjDQO348VBRbtxEicSAgfGZ42HwzzbZjFIK11xzDV5++WWsXr0aJSUlIT+fOHEiUlJS8Pbbb5u3bd++HRUVFZg0aVKvtam2ttacfYkoeHoUP/bMFFVuFIa56WN2epibPiuy4ww52YYRCKBo3Tqrm0FkiQACWLeP2z/Zz/z58/H000/j1VdfRWZmpnleuMfjQXp6OjweD6644grccMMNyMnJQVZWFq699lpMmjQpqius6zAMwzzvvFP8HPIwUeVGYZibPmanh7npsyI7TrWQbSghcHDAAKgO5StEyUJAYEDKAAhw+yd7WbFiBbxeL0499VQUFBSYX88995y5zgMPPIDvf//7mDt3LqZOnYr8/Hy89NJLvdYmpRQOHjzY9QwIB+RhosqNwjA3fcxOD3PTZ0V2HJCTbSjDQP3IkSxZp6RkwMDIjJEsWSfbCV7k5vCvyy67zFwnLS0NjzzyCOrr69HU1ISXXnqp0/PH49Wm+vr66Abkfn+vtcNuosqNwjA3fcxOD3PTZ0V2LFkn2zACARSuX291M4gsEUAA673c/oniwTAMFBYWdr0SZ8jDRJUbhWFu+pidHuamz4rsONVCtqGEQFNeHkvWKSkJCOSl5rFknSgOlFJoamriRd1iFFVuFIa56WN2epibPiuy44CcbEMJgYbiYg7IKSkJCBSnF3NAThQHSik0NDTwHPIYRZUbhWFu+pidHuamz4rsWLJOtmFIiYKNG61uBpElJCQ2ern9E8WDYRgoKCjoeiUOyMNElRuFYW76mJ0e5qbPiuw4Q062oYTAgcJCzpBTUhIQKHQVcoacKA6UUjhw4AAv6hajqHKjMMxNH7PTw9z0WZEdB+RkG0oINOfnc0BOSUlAID81nwNyojhQSqG5uZnnkMcoqtwoDHPTx+z0MDd9VmTHknWyDUNK5G3ebHUziCwhIbH5ALd/ongwDAN5eXldr8SS9TBR5UZhmJs+ZqeHuemzIjvOkJNtKMOAd9gwfg45JSUDBoalDePnkBPFgVIKXq+XF3WLUVS5URjmpo/Z6WFu+qzIjkd2ZBsKgM/jAf+0ULLyOD1WN4EoISil4PP5eA55jKLKjcIwN33MTg9z02dFdixZJ9swpETup59a3QwiS0hIfNrI7Z8oHgzDQG5ubtcrcYY8TFS5URjmpo/Z6WFu+qzIjjPkZBvKMLB/+HCWrFNSMmBgePpwlqwTxYFSCvv37+dF3WIUVW4UhrnpY3Z6mJs+K7LjkR3ZhgLgd7lYsk5Jy2W4rG4CUUJQSsHv9/Mc8hhFlRuFYW76mJ0e5qbPiuxYsk62YUiJgdu2Wd0MIktISGxr4vZPFA+GYWDgwIFdr8QBeZiocqMwzE0fs9PD3PRZkR1nyMk2lGGgfuRIlqxTUjJgYGTGSJasE8WBUgr19fW8qFuMosqNwjA3fcxOD3PTZ0V2PLIjIiIiOhzPIScioj7AknWyDSElcrZvt7oZRJaQkNjezO2fKB6EEMjJyel6JZash4kqNwrD3PQxOz3MTZ8V2XGGnGxDGgbqxoyBZMk6JSEDBsa4x7BknSgOpJSoq6uDlLLzlTggDxNVbhSGueljdnqYmz4rsuORHdmGAOD0+SCsbgiRRXzSZ3UTiBKCEAJOpxNCdLFH4TnkYaLKjcIwN33MTg9z02dFdixZJ9sQUqL/jh1WN4PIEhISOw5y+yeKByEE+vfv3/VKnCEPE1VuFIa56WN2epibPiuy4ww52YY0DOwZN44l65SUDBgY128cS9aJ4kBKiT179nRdksiLuoWJKjcKw9z0MTs9zE2fFdnxyI5sQwBweb0sWaek5fV7rW4CUUIQQsDlckVXss4BuSmq3CgMc9PH7PQwN31WZMeSdbINISU85eVWN4PIEhIS5S3c/oniQQgBj8fT9UockIeJKjcKw9z0MTs9zE2fFdlxhpxsQxoGaiZOZMk6JSUDBiZmTmTJOlEcSClRU1MT3VXWeVE3U1S5URjmpo/Z6WFu+qzIjkd2ZBtCKWTs3g2hlNVNIepzCgq7W3dDgds/UU8JIZCRkdF1SSLPIQ8TVW4UhrnpY3Z6mJs+K7JjyTrZhlAKmVVVVjeDyBIKClU+bv9E8SCEQGZmZtcrsWQ9TFS5URjmpo/Z6WFu+qzIzvIZ8qqqKlx88cUYMGAA0tPTcdxxx+HDDz80f66UwqJFi1BQUID09HTMmDEDX375pYUtJqtIw0B1aSlL1ikpGTBQ6illyTpRHEgpUV1dHV3JOgfkpqhyozDMTR+z08Pc9FmRnaVHdvv27cOUKVOQkpKCv//979i2bRt+/etfIzs721xnyZIleOihh/Doo49i48aNcLvdmDVrFlpaWixsOVlBKIWssjKWrFNSUlAoO1jGknWiOBBCICsrK7qrrPMcclNUuVEY5qaP2elhbvqsyM7SkvX77rsPRUVFePzxx83bSkpKzGWlFJYvX47bbrsNZ599NgDgySefRF5eHl555RVceOGFfd5mso5QCu6aGqubQWQJBYWaVm7/RPEghIDb7e56Jc6Qh4kqNwrD3PQxOz3MTZ8V2Vk6Q/7aa6/hhBNOwPnnn4/c3FxMmDABjz32mPnznTt3Yvfu3ZgxY4Z5m8fjQWlpKTZs2BDxMX0+HxoaGkK+AJhlB0opqEMzrFLK2JcPvVsiHY7/LDud5pzV4csAoDpbFgLS4Yi8fKgsO2TZMDpdVoeWZVfLwfZ2XO7YjyO8T9LhwK4pUxA4dJCUCH2y4+tkHPoXy7I49OnxHZcdcERcdor/vE8Yy7KAgAOOiMvBtnRc1umHlX1ywomTPSebj5sIfbLb66SUCtmXxGOZrCGlRFVVVdevAy/qFiaq3CgMc9PH7PQwN31WZGfpgPzrr7/GihUrMGLECLzxxhv46U9/iuuuuw5PPPEEAGD37t0AgLy8vJD75eXlmT873OLFi+HxeMyvoqIiAO3l8cH/g8v19fXwer0AgLq6OnPwXltbi8bGRgBATU0NmpubAQDV1dVoyckBAFRNmQJfVhYAoHLqVLQdeielYvp0BFwuSKcTFdOnQzqdCLhcqJg+HQDQ5najcupUAIAvKwtVU6YAAFpyclBdWgoAaM7NRc2JJwIAGgcPRu2ECQCAhqIi1I0dCwDwlpSgftSo9j6NGIF9I0a092nUKHgPVRnUjR2LhkP9r50wAY2DB7f36cQT0Zyb296n0lLb9ElICQiBA4WFCdMnO75OJeklGOVu79OIjBEYkdHep1HuUShJb+/T2H5jUZTW3qcJmRMw2NXepxM9JyI3tb1PpZ5S5KS092lK9hRkOdv7NDV7KtyO9j5Nz5kOl+GCUzgxPWc6nMIJl+HC9Jz2PrkdbkzNbu9TljMLU7Lb+5STkoNST3ufclNzcaKnvU+DXYMxIbO9T0VpRRjbzz596p/SH26nGxIyYfpkt9cpEAigoqICANDW1obKykoA7W8EVx264GRLSwuqq6sBAM3Nzag5VNXT2NiI2tpaAEBDQwP27t0Lso4QAjk5OdGVrHNAbooqNwrD3PQxOz3MTZ8V2QmlrDshNzU1FSeccALWr19v3nbddddh06ZN2LBhA9avX48pU6bgm2++QUFBgbnOBRdcACEEnnvuubDH9Pl88Pl85vcNDQ0oKirCvn370L9/f3O2WwgBKSWEELEtO50QSkE6HBBSti87nRB+PwQQtmz4/VAAVKRlIaAMA0YgEL4sBIxDM/LmsmFAARGXAUBICWkYEJ0tK9Xe3o7LHfvBPrFP3fTJsUias48S0S+rQ/86LjvggIQMW3YKJ/yq/ZzNWJaDs6oBBMKWBQQkZMiyTj/Yp+Tuk1zUXjFlGIZZbaW77PV6kZ2dDa/Xi6xDb7CRvoaGBng8nvjm+c03QGEhYBhAIBCfxyQioqQR7b7J0hnygoICjBkzJuS20aNHmzMQ+fn5AGDOMATV1NSYPzucy+VCVlZWyBcAGMHB0KHBdfC2mJcPDeiNQOA/y4cGQZGWAUB0tqwUjEM7+bDlQ2USIctSdrosDi0bXS0H29txuWM/jvA+SYcDVSefbJZrJ0Kf7Pg6yUP/YlkOXois43IAgYjLwUFQrMsKCgEEIi4H29JxWacfVvbJgIEp2VPggCNh+mS310kIEbIviccyWUNKicrKyuiusi5l+xdFlxuFYW76mJ0e5qbPiuwsPSKYMmUKtm/fHnLbF198gWHDhgFov8Bbfn4+3n77bfPnDQ0N2LhxIyZNmtSnbSXrCSkxaMsWc/BKlEwkJLYc2GIONolInxACgwYNiq5kHeCV1g+JKjcKw9z0MTs9zE2fFdlZepX166+/HpMnT8a9996LCy64AB988AF+//vf4/e//z2A9kAWLFiAu+++GyNGjEBJSQluv/12DB48GHPmzLGy6WQBoRTSDp3zT5RsFBS8fm7/RPEghEBaWlrXKzk7HCK1tQGpqb3bKBuIKjcKw9z0MTs9zE2fFdlZOkN+4okn4uWXX8YzzzyDsWPH4le/+hWWL1+Oiy66yFxn4cKFuPbaazFv3jyceOKJaGxsxD/+8Q9uZElIOp0oP3SxMqJk0/HiYkTUM1JKlJeXR1eyDvDCbodElRuFYW76mJ0e5qbPiuwsvahbX4j7hV5Y+mEZhfYrhac0NYGvgjXEnVa3ILm5HW40BZqsbkbSUnfEb3fZKxchS2Kx5qmUQltbG1JSUjovS5QSOPSRkKitBQYOjGOL7Smq3CgMc9PH7PQwN33xzC7afROnWsg2BIDUJg5GKHlxME4UH0IIpHZXgm4Y7V9Scob8kKhyozDMTR+z08Pc9FmRHS/zSrYhnU6UzZzJknVKSk7hxMwBM1myThQHUkqUlZV1X5IY3N9wQA4ghtwoBHPTx+z0MDd9VmTHATnZhvD7MWTtWghe7ZaSkF/5sXbf2pCP4yIiPUIIDBkypPtyxOB55ByQA4ghNwrB3PQxOz3MTZ8V2XFATrYhcOgzuK1uCJFFAipgdROIEkLws+A5II9N1LlRCOamj9npYW76rMiOA3KyDel0ooJXWackxausE8WPlBIVFRXdlyQGB+SszAIQQ24UgrnpY3Z6mJs+K7LjgJxsw/D7MXT1ahg8MKIk5Fd+rK5fzZJ1ojgwDANDhw6FYXRzGMQZ8hBR50YhmJs+ZqeHuemzIju+SmQbCoB0OJDQn9NH1AWHcFjdBKKEoJSClBLdfvIrL+oWIurcKARz08fs9DA3fVZkxwE52YZyOrFr2jQolqxTEnIKJ6ZlT2PJOlEcKKWwa9eu7g+4OEMeIurcKARz08fs9DA3fVZkxyM7sg3D70fxqlVWN4PIEn7lx6q93P6J4sEwDBQXF3e/Is8hDxF1bhSCueljdnqYmz4rsuMMOdmGAtDqdrNknZKW2+G2uglECUEphdbWVs6Qxyjq3CgEc9PH7PQwN31WZMcBOdmGcjpRXVrKknVKSk7hRKmnlCXrRHGglEJ1dTXPIY9R1LlRCOamj9npYW76rMiOR3ZkG4bfj2GrV1vdDCJLBK+yTkQ9ZxgGhg0b1v2KnCEPEXVuFIK56WN2epibPiuy4ww52YYSAi0eD5QQVjeFqM8JCHicHghw+yfqKaUUWlpaWLIeo6hzoxDMTR+z08Pc9FmRHQfkZBvKMFA7fjwUP1ORkpABA+Mzx8Pgn22iHlNKoba2NvoBOS/qBiCG3CgEc9PH7PQwN31WZMeSdbINIxBA0bp1VjeDyBIBBLBuH7d/ongwDANFRUXdr8gZ8hBR50YhmJs+ZqeHuemzIjtOtZBtKCFwcMAAlqxTUhIQGJAygCXrRHGglMLBgwd5UbcYRZ0bhWBu+pidHuamz4rsOCAn21CGgfqRI1myTknJgIGRGSNZsk4UB0op1NfX8xzyGEWdG4VgbvqYnR7mps+K7FiyTrZhBAIoXL/e6mYQWSKAANZ7uf0TxYNhGCgsLOx+RZ5DHiLq3CgEc9PH7PQwN31WZMepFrINJQSa8vJYsk5JSUAgLzWPJetEcaCUQlNTE2fIYxR1bhSCueljdnqYmz4rsuOAnGxDCYGG4mIOyCkpCQgUpxdzQE4UB0opNDQ08BzyGEWdG4VgbvqYnR7mps+K7FiyTrZhSImCjRutbgaRJSQkNnq5/RPFg2EYKCgo6H5FzpCHiDo3CsHc9DE7PcxNnxXZcYacbEMJgQOFhZwhp6QkIFDoKuQMOVEcKKVw4MABlqzHKOrcKARz08fs9DA3fVZkxwE52YYSAs35+RyQU1ISEMhPzeeAnCgOlFJobm6OfkDOi7oBiCE3CsHc9DE7PcxNnxXZsWSdbMOQEnmbN1vdDCJLSEhsPsDtnygeDMNAXl5e9ytyhjxE1LlRCOamj9npYW76rMiOM+RkG8ow4B02jJ9DTknJgIFhacP4OeREcaCUgtfr5UXdYhR1bhSCueljdnqYmz4rsuORHdmGAuDzeMA/LZSsPE6P1U0gSghKKfh8Pp5DHqOoc6MQzE0fs9PD3PRZkR1L1sk2DCmR++mnVjeDyBISEp82cvsnigfDMJCbm9v9ijyHPETUuVEI5qaP2elhbvqsyI4z5GQbyjCwf/hwlqxTUjJgYHj6cJasE8WBUgr79+/nDHmMos6NQjA3fcxOD3PTZ0V2PLIj21AA/C4XS9YpabkMl9VNIEoISin4/X6eQx6jqHOjEMxNH7PTw9z0WZEdS9bJNgwpMXDbNqubQWQJCYltTdz+ieLBMAwMHDiw+xU5Qx4i6twoBHPTx+z0MDd9VmTHGXKyDWUYqB85kiXrlJQMGBiZMZIl60RxoJRCfX09S9ZjFHVuFIK56WN2epibPiuy45EdERERUSS8qBsREfUylqyTbQgpkbN9u9XNILKEhMT2Zm7/RPEghEBOTk73K3KGPETUuVEI5qaP2elhbvqsyI4z5GQb0jBQN2YMJEvWKQkZMDDGPYYl60RxIKVEXV0dpJRdr8iLuoWIOjcKwdz0MTs9zE2fFdnxyI5sQwBw+nwQVjeEyCI+6bO6CUQJQQgBp9MJIbrZo3CGPETUuVEI5qaP2elhbvqsyI4l62QbQkr037HD6mYQWUJCYsdBbv9E8SCEQP/+/btfkeeQh4g6NwrB3PQxOz3MTZ8V2XGGnGxDGgb2jBvHknVKSgYMjOs3jiXrRHEgpcSePXu6L0nkDHmIqHOjEMxNH7PTw9z0WZEdj+zINgQAl9fLknVKWl6/1+omECUEIQRcLhdL1mMUdW4UgrnpY3Z6mJs+K7LjgJxsQ0gJT3k5BN/toyQkIVHeUg4Jbv9kL+vWrcOZZ56JwYMHQwiBV155JeTnl112GYQQIV9nnHFGr7ZJCAGPx9P9ARcv6hYi6twoBHPTx+z0MDd9VmTHATnZhjQM1EycyJJ1SkoGDEzMnMiSdbKdpqYmjB8/Ho888kin65xxxhmorq42v5555plebZOUEjU1NSxZj1HUuVEI5qaP2elhbvqsyI4XdSPbEEohY/duCKWsbgpRn1NQ2N26Gwrc/sleZs+ejdmzZ3e5jsvlQn5+fh+1qH0GJCMjI/qSdV7UDUAMuVEI5qaP2elhbvqsyI5TLWQbQilkVlVxQE5JSUGhylfFATklpHfeeQe5ubkYOXIkfvrTn2Lv3r1dru/z+dDQ0BDyBcCc0VBKQR3aV0gpw5aFEHC73ebjRVoHAKTD0b5CW1vn63R4zt5e7qpP8V7u7PkzMzPj2m+r+9QXr1PU25uN+tRXr5MQAv369TN/ngh96ovXSSmFfv36QQiRMH3qq9cJANxuN4QQcetHdzggJ9uQhoHq0lKWrFNSMmCg1FPKknVKOGeccQaefPJJvP3227jvvvuwdu1azJ49G4FAoNP7LF68GB6Px/wqKioCAOzbt8/8P7hcX18Pr7f9goh1dXVoaGiAlBLbt283B/I1NTVobm4GAFRXV6OlpQUAUHvoMdDWhsrKSrQdKl2vqKhAIBCAlBIVFRWQUiIQCKCiouLQ6u3rA+1vHlRVVQEAWlpaUF1dDQBobm5GTU0NAKCxsRG1tbUAgIaGBtTV1QEAvF4v6uvro+oTANTW1qKxsbHLPlVVVcHn8wFAzH2qqKgwHytR+tQXr5OUEl988YXZv0ToU1+9TlJK7Nq1y+xfIvSpL16nvXv3YseOHZBSJkyf+up1amtrw9atW83lnvSpuzeXg4QKvi2QoBoaGuDxeOD1epGVldXzB2Tph2WUEGjOzUXGnj2cJbeIuNPqFiQvAYHc1Fzsad3DWXKLqDvil3vc9002IYTAyy+/jDlz5nS6ztdff43hw4fjrbfewumnnx5xHZ/PZx5cAe15FhUVYd++fejfv7854xGcHQpeLC64DLQfOLndbhiGEXEdIQTkRx/BmDgRyM+HrKqKvI6UMAzDnMnpzeWu+hTv5UjPL6VES0sL0tPTASAh+tQXr1PU25uN+tRXr5MQAk1NTUhPT4fD4UiIPvXF6xQIBHDw4EG43W4zR7v3qa9eJyklmpqa0K9fPwDoUdu9Xi+ys7O73dfzHHKyDaEU3IfegSJKNgoKNa3c/inxHXXUURg4cCC++uqrTgfkLpcLLpcr7HbjUAVVcBDU8bbDl4Ol112tYwSfw+/vfJ0Ozxl83t5a7ra9cV4+/PkdDkdI6XUi9KmvXqeotjeb9amvXqfgwCiR+tTbr5PD4TBz682+JuK2ZxhGyO9rT9re8fG7wtpHsg3pcKBq8uT/nNNHlEQccGCyZzIc4PZPiW3Xrl3Yu3cvCgoKeu05pJSoqqrq/vw+XmU9RNS5UQjmpo/Z6WFu+qzIjjPkZBtCSuRs387PIaekJCGxvXk7P4ecbKexsRFfffWV+f3OnTvxySefICcnBzk5Objrrrswd+5c5OfnY8eOHVi4cCGOPvpozJo1q9faJIRATk5OyOxLRByQh4g6NwrB3PQxOz3MTZ8V2XFATrYhlEJ6lBdHIEo0Cgp727j9k/18+OGHOO2008zvb7jhBgDApZdeihUrVuDTTz/FE088gf3792Pw4MGYOXMmfvWrX0UsSY8XIYR5HnSXnIcOkzggBxBDbhSCueljdnqYmz4rsuOAnGxDOhyomjIFhf/8J4wurr5LlIgccGBK9hT8c98/EQC3f7KPU0891bwwTyRvvPFGH7amXbAksbCwsOtz/DrOkCuV9Bd2jTo3CsHc9DE7PcxNnxXZ8RUi2xBSYtCWLSxZp6QkIbHlwBaWrBPFgRACgwYNir5kHQC474k+NwrB3PQxOz3MTZ8V2XGGnGxDKIW0Q58/SJRsFBS8fm7/RPEghEBaWlr3K3YckLe1AUl+UdGoc6MQzE0fs9PD3PRZkR1nyMk2pNOJ8unTIZ18H4mSj1M4MT1nOpyC2z9RT0kpUV5e3v1VdDvub3geefS5UQjmpo/Z6WFu+qzIjgNysg3h96Ng40YIv9/qphD1Ob/yY6N3I/yK2z9RTwkhUFBQEFvJOgfk0edGIZibPmanh7npsyI7TrWQbQgAqU1NVjeDyDJNAW7/RPEghEBqamr3K3acIeebwdHnRiGYmz5mp4e56bMiO86Qk21IpxNlM2eyZJ2SklM4MXPATJasE8WBlBJlZWXdlyQKwY8+6yDq3CgEc9PH7PQwN31WZMcBOdmG8PsxZO1alqxTUvIrP9buW8uSdaI4EEJgyJAh0ZUkdvzosyQXU25kYm76mJ0e5qbPiuy0BuQfffQRtm7dan7/6quvYs6cOfj5z3+O1tbWuDWOqCMBwAgEwD8tlKwCip8/Tn0nkff1QggYhhHdARdnyE0x5UYm5qaP2elhbvqsyE5rQH7VVVfhiy++AAB8/fXXuPDCC5GRkYEXXngBCxcujGsDiYKk04kKXmWdkhSvsk59LZH39VJKVFRURFeSyBlyU0y5kYm56WN2epibPiuy0xqQf/HFFzj++OMBAC+88AKmTp2Kp59+GitXrsRf/vKXeLaPyGT4/Ri6ejUMlqxTEvIrP1bXr2bJOvWZRN7XG4aBoUOHwjCiOAwKDsi574ktNzIxN33MTg9z02dFdlrPpJQy3zV466238N3vfhcAUFRUhLq6uvi1jqgDBUA6HFBWN4TIIg7hsLoJlEQSeV8f7JtSUexROENuiik3MjE3fcxOD3PTZ0V2WgPyE044AXfffTeeeuoprF27Ft/73vcAADt37kReXl5cG0gUpJxO7Jo2DYol65SEnMKJadnTWLJOfSaR9/VKKezatSu6Ay6eQ26KKTcyMTd9zE4Pc9NnRXZaA/Lly5fjo48+wjXXXINf/OIXOProowEAL774IiZPnhzXBhIFGX4/iletYsk6JSW/8mPV3lUsWac+k8j7esMwUFxcHFvJOgfkseVGJuamj9npYW76rMhOa6pl3LhxIVdeDVq6dCkcDpZUUu9QANrcbqQ0NfFK65SU3A43mgJNVjeDkkQi7+uVUmhra0NKSkr3V9LlOeSmmHIjE3PTx+z0MDd9VmSnNfTftGkTNm7cGHb7li1bsGXLlh43iigS5XSiurSUJeuUlJzCiVJPKUvWqc8k8r5eKYXq6mqeQx6jmHIjE3PTx+z0MDd9VmSnNSCfP38+Kisrw26vqqrC/Pnze9wookgMvx/DeJV1SlK8yjr1tUTe1xuGgWHDhrFkPUYx5UYm5qaP2elhbvqsyE7rmbZt24ZvfetbYbdPmDAB27Zt63GjiCJRQqDF44Fi6Q0lIQEBj9MDwRM2qI8k8r5eKYWWlhZe1C1GMeVGJuamj9npYW76rMhOa0DucrlQU1MTdnt1dTWcLCemXqIMA7Xjx0Px3T5KQgYMjM8cD0PvzzZRzBJ5X6+UQm1tLUvWYxRTbmRibvqYnR7mps+K7LSO7GbOnIlbb70VXq/XvG3//v34+c9/ju985ztxaxxRR0YggKJ162AEAlY3hajPBRDAun3rEAC3f+obibyvNwwDRUVFsZWs83Sp2HIjE3PTx+z0MDd9VmSn9Rb3/fffj6lTp2LYsGGYMGECAOCTTz5BXl4ennrqqbg2kChICYGWnByk1ddD8B0/SjICAjkpOahvq4cCt3/qfYm8rw+WJKalpUV/lXXOkMeWG5mYmz5mp4e56bMiO62hf2FhIT799FMsWbIEY8aMwcSJE/Hggw9i69atKCoqincbiQC0l6zXjxzJknVKSgYMjMwYyZJ16jOJvK9XSqG+vp4l6zGKKTcyMTd9zE4Pc9NnRXbaJ4G53W7Mmzcvnm0h6pIRCKBw/Xqrm0FkiQACWO/l9k99K1H39YZhoLCwMLqVeVE3U0y5kYm56WN2epibPiuy055qeeqpp3DyySdj8ODBKC8vBwA88MADePXVV+PWOKKOlBBoysvjVdYpKQkI5KXm8Srr1KcSdV+vlEJTU1NsM+Q8hzy23MjE3PQxOz3MTZ8V2WkNyFesWIEbbrgBs2fPxr59+xA4dJGt7OxsLF++PJ7tIzIpIdBQXMwBOSUlAYHi9GIOyKnPJPK+XimFhoYGlqzHKKbcyMTc9DE7PcxNnxXZaQ3IH374YTz22GP4xS9+EfLRJyeccAK2bt0at8YRdWRIiYKNG2FIaXVTiPqchMRG70ZIcPunvpHI+3rDMFBQUBDbVdY5II8tNzIxN33MTg9z02dFdlrPtHPnTvOKqx25XC40NTX1uFFEkSghcKCwkDPklJQEBApdhZwhpz6TyPt6pRQOHDgQ3QwIzyE3xZQbmZibPmanh7npsyI7rQF5SUkJPvnkk7Db//GPf2D06NE9bRNRREoINOfnc0BOSUlAID81nwNy6jOJvK9XSqG5uZkl6zGKKTcyMTd9zE4Pc9NnRXZaV1m/4YYbMH/+fLS0tEAphQ8++ADPPPMMFi9ejD/84Q/xbiMRgPaS9bzNm61uBpElJCQ2H+D2T30nkff1hmEgLy8vupV5UTdTTLmRibnpY3Z6mJs+K7LTGpBfeeWVSE9Px2233Ybm5mb88Ic/RGFhIR588EFceOGF8W4jEYD2zyFvKCpCVmUlBM8jpyRjwEBRWhEqWyp5Hjn1iUTe1wcv2pOVlQXRXdUVZ8hNMeVGJuamj9npYW76rMhOq2T94MGDOOecc/Dll1+isbER77//Pm644QYMGTIk3u0jMikAPo8HLL6hZOVxeqxuAiWRRN7XK6Xg8/lYsh6jmHIjE3PTx+z0MDd9VmSnNSA/++yz8eSTTwIAWltbcdZZZ2HZsmWYM2cOVqxYEdcGEgUZUiL30095lXVKShISnzZ+ytlx6jOJvK83DAO5ubnRXUWXF3UzxZQbmZibPmanh7npsyI7rWf66KOPcMoppwAAXnzxReTl5aG8vBxPPvkkHnroobg2kChIGQb2Dx8OxT8ulIQMGBiePhyG3p9topgl8r5eKYX9+/fHNkPOc8hjy41MzE0fs9PD3PRZkZ3WkV1zczMyMzMBAKtWrcK5554LwzDw7W9/G+Xl5XFtIFGQAuB3uViyTknLZbisbgIlkUTe1yul4Pf7WbIeo5hyIxNz08fs9DA3fVZkpzUgP/roo/HKK6+gsrISb7zxBmbOnAkA2LNnD7KysuLaQKIgQ0oM3LaNJeuUlCQktjVtY8k69ZlE3tcbhoGBAwdGV5LIAbkpptzIxNz0MTs9zE2fFdlpPdOiRYtw0003obi4GKWlpZg0aRKA9nfQJ0yYENcGEgUpw0D9yJEsWaekZMDAyIyRLFmnPpPI+3qlFOrr66ObAeE55KaYciMTc9PH7PQwN31WZKf1sWfnnXceTj75ZFRXV2P8+PHm7aeffjrOOeecuDWOiIiIrMF9/SGcISciol6kNSAHgPz8fOTn54fcdtJJJ/W4QUSdEVIiZ/t2q5tBZAkJie3N3P6pbyXqvl4IgZycnOhW5kXdTDHlRibmpo/Z6WFu+qzIjrWPZBvSMFA3ZgwkS9YpCRkwMMY9hiXrRHEgpURdXR1kNNck4Qy5KabcyMTc9DE7PcxNnxXZ8ciObEMAcPp8EFY3hMgiPumzuglECUEIAafTCSGi2KNwQG6KKTcyMTd9zE4Pc9NnRXbaJetEfU1Iif47dljdDCJLSEjsOMjtnygehBDo379/dCvzom6mmHIjE3PTx+z0MDd9VmTHGXKyDWkY2DNuHEvWKSkZMDCu3ziWrBPFgZQSe/bsia1kneeQx5YbmZibPmanh7npsyI7HtmRbQgALq+XJeuUtLx+r9VNIEoIQgi4XC6WrMcoptzIxNz0MTs9zE2fFdkdMQPy//3f/4UQAgsWLDBva2lpwfz58zFgwAD069cPc+fORU1NjXWNJEsJKeEpL4fgu32UhCQkylvKIcHtn6inhBDweDwckMcoptzIxNz0MTs9zE2fFdkdEQPyTZs24Xe/+x3GjRsXcvv111+Pv/71r3jhhRewdu1afPPNNzj33HMtaiVZTRoGaiZOZMk6JSUDBiZmTmTJOlEcSClRU1MTXUkizyE3xZQbmZibPmanh7npsyI7y4/sGhsbcdFFF+Gxxx5Ddna2ebvX68X//d//YdmyZZg+fTomTpyIxx9/HOvXr8f7779vYYvJKkIpZOzeDaGU1U0h6nMKCrtbd0OB2z9RTwkhkJGRwRnyGMWUG5mYmz5mp4e56bMiO8sH5PPnz8f3vvc9zJgxI+T2zZs3o62tLeT2UaNGYejQodiwYUOnj+fz+dDQ0BDyBcB8l0MpBXVoQCeljH350IsjHY7/LDud5iHy4csAoDpbFgLS4Yi8fGgWOGTZMDpdVoeWZVfLwfZ2XO7YjyO8T0IpuKurgUj9sGmf7Pg6GYf+xbIsDp3533HZAUfEZaf4z4c/xLIsIOCAI+JysC0dl3X6YWWfAGC3r31Anih9stvrpJQK2ZfEY5msIYRAZmZmbANyXtQtttzIxNz0MTs9zE2fFdlZOiB/9tln8dFHH2Hx4sVhP9u9ezdSU1PDLjufl5eH3bt3d/qYixcvhsfjMb+KiooAAPv27TP/Dy7X19fD622/SFJdXZ05eK+trUVjYyMAoKamBs3NzQCA6upqtOTkAACqpkyBLysLAFA5dSra3G4AQMX06Qi4XJBOJyqmT4d0OhFwuVAxfToAoM3tRuXUqQAAX1YWqqZMAQC05OSgurQUANCcm4uaE08EADQOHozaCRMAAA1FRagbOxYA4C0pQf2oUe19GjEC+0aMaO/TqFHwlpS092nsWDQc6n/thAloHDy4vU8nnojm3Nz2PpWW2qZP0jDwxfnnwztsWML0yY6vU0l6CUa52/s0ImMERmS092mUexRK0tv7NLbfWBSltfdpQuYEDHa19+lEz4nITW3vU6mnFDkp7X2akj0FWc72Pk3Nngq3o71P03Omw2W44BROTM+ZDqdwwmW4MD2nvU9uhxtTs9v7lOXMwpTs9j7lpOSg1NPep9zUXJzoae/TYNdgTMhs71NRWhHG9rNPnwamDMTFBRfDgJEwfbLb6xQIBFBRUQEAaGtrQ2VlJYD2N4KrqqoAtF/7pLq6GgDQ3NxsXveksbERtbW1AICGhgbs3bsXZB0pJaqrq2O7yjpnyGPLjUzMTR+z08Pc9FmRnVDKmvrfyspKnHDCCXjzzTfNc8dPPfVUHH/88Vi+fDmefvppXH755fD5fCH3O+mkk3Daaafhvvvui/i4Pp8v5D4NDQ0oKirCvn370L9/f3O2WwgBKSWEELEtO50QSkE6HBBSti87nRB+PwQQtmz4/VAAVKRlIaAMA0YgEL4sBIxDM/LmsmFAARGXgfaLnknDgOhsWan29nZc7tiPI7xPUAqN+flw79kDIxBIiD7Z7XVyLJLm7KNE9Mvq0L+Oyw44ICHDlp3CCb9qn4mKZTk4qxpAIGxZQEBChizr9MPKPhkwkJeah92t7W9IJkKf7PY6yUXtFVOGYZjVVrrLXq8X2dnZ8Hq9yDr0Bhvpa2hogMfjiTpPpRSam5ujK0v86CNg4kSgsBDYtStOLbanmHIjE3PTx+z0MDd98cwu2n2Ts9Of9LLNmzdjz549+Na3vmXeFggEsG7dOvzmN7/BG2+8gdbWVuzfvz9klrympgb5+fmdPq7L5YLL5Qq73QgOhjoEG7wtpuVDA3ojEPjP7R3K2CItCwAi0rJSEIceJ2w5+MZBx2UpzY/8OnzZfM5Ylzv2wwZ9yjw085RIfbLb69TxKt89WQ4gEHE5OAiKdVlBmY9z+HLwvOuOy/HqR1/1SUKiuvU/238i9Mlur1Pwzdl4LHfct1DfE0LAfai6qFu8qJspptzIxNz0MTs9zE2fFdlZdkRw+umnY+vWrfjkk0/MrxNOOAEXXXSRuZySkoK3337bvM/27dtRUVGBSZMmWdVsspB0OFA1ebJ5vjNRMnHAgcmeySHnlBORHiklqqqqYitZ5znkseVGJuamj9npYW76rMjOshnyzMxMjD10TmqQ2+3GgAEDzNuvuOIK3HDDDcjJyUFWVhauvfZaTJo0Cd/+9retaDJZTEiJnO3b+TnklJQkJLY3b+fnkBPFgRACOTk5vMp6jGLKjUzMTR+z08Pc9FmRnWUD8mg88MADMAwDc+fOhc/nw6xZs/Db3/7W6maRRYRSSOeFkChJKSjsbeP2TxQPQgikp6dHtzIH5KaYciMTc9PH7PQwN31WZHdEncT2zjvvYPny5eb3aWlpeOSRR1BfX4+mpia89NJLXZ4/TolNOhyonDqVJeuUlBxwYGr2VJasE8WBlBKVlZW8ynqMYsqNTMxNH7PTw9z0WZHdETUgJ+qKkBKDtmxhyTolJQmJLQe2sGSdKA6EEBg0aFB0JYnBi7oFAuaFXZNVTLmRibnpY3Z6mJs+K7I7okvWiToSSiHt0OfGEyUbBQWvn9s/UTwIIZCWlhbdysEZcqD9wm4dv08yMeVGJuamj9npYW76rMiOM+RkG9LpRPn06ZBOvo9EyccpnJieMx1Owe2fqKeklCgvL4+tZB1I+rL1mHIjE3PTx+z0MDd9VmTHATnZhvD7UbBxo/lZ2kTJxK/82OjdGPL52ESkRwiBgoKC2K6yDiT9gDym3MjE3PQxOz3MTZ8V2XGqhWxDAEhtarK6GUSWaQpw+yeKByEEUlNTo1u5Y1UWB+TR50Ym5qaP2elhbvqsyI4z5GQb0ulE2cyZLFmnpOQUTswcMJMl60RxIKVEWVlZdCWJDgcQnClJ8gqtmHIjE3PTx+z0MDd9VmTHATnZhvD7MWTtWpasU1LyKz/W7lvLknWiOBBCYMiQIdGXJPKjzwBo5EYAmFtPMDs9zE2fFdlxQE62IQAYgQD4p4WSVUAFrG4CUUIQQsAwDA7IYxRzbgSAufUEs9PD3PRZkR0H5GQb0ulEBa+yTkmKV1knih8pJSoqKqIvSeSAHIBGbgSAufUEs9PD3PRZkR0H5GQbht+PoatXw2DJOiUhv/Jjdf1qlqwTxYFhGBg6dCgMI8rDoOAbwUk+II85NwLA3HqC2elhbvqsyI6vEtmGAiAdDiirG0JkEYdwWN0EooSglIKUEkpFuUcJzpAn+RvCMedGAJhbTzA7PcxNnxXZcUBOtqGcTuyaNg2KJeuUhJzCiWnZ01iyThQHSins2rUr9gF5ks+Qx5wbAWBuPcHs9DA3fVZkxyM7sg3D70fxqlVWN4PIEn7lx6q93P6J4sEwDBQXF0d/Bw7IAWjkRgCYW08wOz3MTZ8V2XGGnGxDAWh1u1myTknL7XBb3QSihKCUQmtra/QzIDyHHIBGbgSAufUEs9PD3PRZkR0H5GQbyulEdWkpS9YpKTmFE6WeUpasE8WBUgrV1dU8hzxGMedGAJhbTzA7PcxNnxXZ8ciObMPw+zFs9Wqrm0FkieBV1omo5wzDwLBhw6K/A0vWAWjkRgCYW08wOz3MTZ8V2XGGnGxDCYEWjwdKCKubQtTnBAQ8Tg8EuP0T9ZRSCi0tLbyoW4xizo0AMLeeYHZ6mJs+K7LjgJxsQxkGasePh+JnKlISMmBgfOZ4GPyzTdRjSinU1tZyQB6jmHMjAMytJ5idHuamz4rsWLJOtmEEAihat87qZhBZIoAA1u3j9k8UD4ZhoKioKPo78KJuADRyIwDMrSeYnR7mps+K7DjVQrahhMDBAQNYsk5JSUBgQMoAlqwTxYFSCgcPHuRF3WIUc24EgLn1BLPTw9z0WZEdB+RkG8owUD9yJEvWKSkZMDAyYyRL1oniQCmF+vp6lqzHKObcCABz6wlmp4e56bMiOx7ZkW0YgQAK16+HEQhY3RSiPhdAAOu96xEAt3+yl3Xr1uHMM8/E4MGDIYTAK6+8EvJzpRQWLVqEgoICpKenY8aMGfjyyy97tU2GYaCwsBBGtG/wckAOQCM3AsDceoLZ6WFu+qzIjq8S2YYSAk15eSxZp6QkIJCXmseSdbKdpqYmjB8/Ho888kjEny9ZsgQPPfQQHn30UWzcuBFutxuzZs1CS0tLr7VJKYWmpqboZ0B4DjkAjdwIAHPrCWanh7npsyI7DsjJNpQQaCgu5oCckpKAQHF6MQfkZDuzZ8/G3XffjXPOOSfsZ0opLF++HLfddhvOPvtsjBs3Dk8++SS++eabsJn0jnw+HxoaGkK+AEBKaT5u8GBKShm2rJSC1+s114+0TsjyoRlydWhAfvg6wefs7eUu2xjn5UjPHwgE0NDQACllwvSpL16nmLc3G/Spr16nYHaBQ9WRidCnvnidAoEAvF5vSI5271NfvU5SSuzfv9987nj0ozsckJNtGFKiYONGGFFu3ESJREJio3cjJLj9U+LYuXMndu/ejRkzZpi3eTwelJaWYsOGDZ3eb/HixfB4POZX8Iq4+/btM/8PLtfX18Pr9QIA6urq0NDQAMMw4HA40NzcDACoqakxl6urq83Z+aqqKvh8PnNAHjh0e0VFBQKBAKSUqKiogJQSgUAAFRUVAIC2tjZUVlYCaH/zoKqqCgDQ0tKC6upqAEBzczNqamoAAI2NjaitrQUANDQ0oK6uDgDg9XpRX18fVZ8AoLa2Fo2NjdH1CUBlZSXaDr3JEE2fqqqqUFBQYC4nQp/64nUyDANOp9PsRyL0qa9eJ8MwMHDgQLMfidCnvnid9u/fj4yMDBiGkTB96qvXSSmFtrY2GIbR4z7t3bsX0RAq+LZAgmpoaIDH44HX60VWVlbPH5Czs5ZRQqBx8GD0++YbiMTebI9Y4k6rW5C8BAQGuwbjG983UOD2bwV1R/xyj/u+ySaEEHj55ZcxZ84cAMD69esxZcoUfPPNNygoKDDXu+CCCyCEwHPPPRfxcXw+n3lwBbTnWVRUhH379qF///7mjIcQAlJKCCFCloP3yczMhGEYEdcJWb7iCuDxx6HuvRfi1lvD1jEMw5xN6c3lrvoU7+VIzy+lRHNzM9xuNwAkRJ/64nWKeXuzQZ/66nUSQuDAgQNwu91wOBwJ0ae+eJ0CgQCampqQmZlp5mj3PvXV6ySlxIEDB8x9c0/a7vV6kZ2d3e2+np9DTrahhEBzfj7c1dUckFPSERDIT81Hta+aA3JKei6XCy6XK+z24EV4goOgjrd1XJZSoqWlBZmZmZ2uE7J8aIZcHPrYs0jrBA/qenO5yzb2wnKktgQH5PHq95HQp3gvH/6cMW9vNuhTby93HCQdPHgQ/fr1S5g+9eZykBDCzC1R+tRXrxMA8/fVMIwetb3jY3aFJetkG4aUyNu8mSXrlJQkJDYf2MySdUoo+fn5AGCW+wXV1NSYP+sNhmEgLy8v6oMlXtStXcy5EQDm1hPMTg9z02dFdnyVyDaUYcA7bBg/h5ySkgEDw9KG8XPIKaGUlJQgPz8fb7/9tnlbQ0MDNm7ciEmTJvXa8wZLCaM+ay/4sWeHZsiTVcy5EQDm1hPMTg9z02dFdixZJ9tQAHweD1RlJa8zTUnJ4/SgEpVWN4MoJo2Njfjqq6/M73fu3IlPPvkEOTk5GDp0KBYsWIC7774bI0aMQElJCW6//XYMHjzYPM+8Nyil4PP5zHMru8XPIQegkRsBYG49wez0MDd9VmTHATnZhiElcj/91OpmEFlCQuLTRm7/ZD8ffvghTjvtNPP7G264AQBw6aWXYuXKlVi4cCGampowb9487N+/HyeffDL+8Y9/IC0trdfaZBgGcnNzo78DB+QANHIjAMytJ5idHuamz4rsWPtItqEMA/uHD2fJOiUlAwaGpw9nyTrZzqmnnmpeebbj18qVKwG0X/jml7/8JXbv3o2Wlha89dZbOOaYY3q1TUop83Nmo8IBOQCN3AgAc+sJZqeHuemzIjse2ZFtKAB+l4vXl6ak5TLCrypNRLFTSsHv90d/wMWLugHQyI0AMLeeYHZ6mJs+K7JjyTrZhiElBm7bZnUziCwhIbGtids/UTwYhoGBAwdGfwde1A2ARm4EgLn1BLPTw9z0WZEdZ8jJNpRhoH7kSJasU1IyYGBkxkiWrBPFgVIK9fX1LFmPUcy5EQDm1hPMTg9z02dFdjyyIyIiIuoKB+RERNRLWLJOtiGkRM727VY3g8gSEhLbm7n9E8WDEAI5OTnR34HnkAPQyI0AMLeeYHZ6mJs+K7LjDDnZhjQM1I0ZA8mSdUpCBgyMcY9hyTpRHEgpUVdXBylldHfgOeQANHIjAMytJ5idHuamz4rseGRHtiEAOH0+CKsbQmQRn/RZ3QSihCCEgNPphBBR7lFYsg5AIzcCwNx6gtnpYW76rMiOJetkG0JK9N+xw+pmEFlCQmLHQW7/RPEghED//v2jvwMH5AA0ciMAzK0nmJ0e5qbPiuw4Q062IQ0De8aNY8k6JSUDBsb1G8eSdaI4kFJiz549sZesJ/mAPObcCABz6wlmp4e56bMiOx7ZkW0IAC6vlyXrlLS8fq/VTSBKCEIIuFyu6EsSeVE3ABq5EQDm1hPMTg9z02dFdixZJ9sQUsJTXm51M4gsISFR3sLtnygehBDweDzR34EXdQOgkRsBYG49wez0MDd9VmTHGXKyDWkYqJk4kSXrlJQMGJiYOZEl60RxIKVETU0NS9ZjFHNuBIC59QSz08Pc9FmRHY/syDaEUsjYvRtCKaubQtTnFBR2t+6GArd/op4SQiAjI4NXWY9RzLkRAObWE8xOD3PTZ0V2LFkn2xBKIbOqyupmEFlCQaHKx+2fKB6EEMjMzIz+DjyHHIBGbgSAufUEs9PD3PRZkR1nyMk2pGGgurSUJeuUlAwYKPWUsmSdKA6klKiuro69ZD3JzyGPOTcCwNx6gtnpYW76rMiOR3ZkG0IpZJWVsWSdkpKCQtnBMpasE8WBEAJZWVksWY9RzLkRAObWE8xOD3PTZ0V2LFkn2xBKwV1TY3UziCyhoFDTyu2fKB6EEHC73dHfgQNyABq5EQDm1hPMTg9z02dFdpwhJ9uQDgeqJk+GdDisbgpRn3PAgcmeyXCA2z9RT0kpUVVVxausxyjm3AgAc+sJZqeHuemzIjsOyMk2hJTI2b4dgn9cKAlJSGxv3g4Jbv9EPSWEQE5OTvQlibyoGwCN3AgAc+sJZqeHuemzIjuWrJNtCKWQvnev1c0gsoSCwt42bv9E8SCEQHp6evR34EXdAGjkRgCYW08wOz3MTZ8V2XGGnGxDOhyonDqVJeuUlBxwYGr2VJasE8WBlBKVlZUsWY9RzLkRAObWE8xOD3PTZ0V2HJCTbQgpMWjLFpasU1KSkNhyYAtL1oniQAiBQYMG8SrrMYo5NwLA3HqC2elhbvqsyI4l62QbQimkeb1WN4PIEgoKXj+3f6J4EEIgLS0t+jsEzyFXCggEgCSt1Io5NwLA3HqC2elhbvqsyI4z5GQb0ulE+fTpkE6+j0TJxymcmJ4zHU7B7Z+op6SUKC8vj71kHUjq88hjzo0AMLeeYHZ6mJs+K7LjgJxsQ/j9KNi4ESKJD4YoefmVHxu9G+FX3P6JekoIgYKCgthL1oGkLluPOTcCwNx6gtnpYW76rMiOUy1kGwJAalOT1c0gskxTgNs/UTwIIZCamhr9HTggB6CRGwFgbj3B7PQwN31WZMcZcrIN6XSibOZMlqxTUnIKJ2YOmMmSdaI4kFKirKws+pLEjvudJB6Qx5wbAWBuPcHs9DA3fVZkxwE52Ybw+zFk7VqWrFNS8is/1u5by5J1ojgQQmDIkCHRlyQK8Z8LuSXxgDzm3AgAc+sJZqeHuemzIjsOyMk2BAAjEAD/tFCyCqiA1U0gSghCCBiGEdsBV7BsPYnfFNbKjZhbDzA7PcxNnxXZcUBOtiGdTlTwKuuUpHiVdaL4kVKioqIitpJEfha5Xm7E3HqA2elhbvqsyI4DcrINw+/H0NWrYSTx7AQlL7/yY3X9apasE8WBYRgYOnQoDCOGwyAOyPVyI+bWA8xOD3PTZ0V2fJXINhQA6XBAWd0QIos4hMPqJhAlBKUUpJRQKoY9SrA6K4kH5Fq5EXPrAWanh7npsyI7DsjJNpTTiV3TpkGxZJ2SkFM4MS17GkvWieJAKYVdu3bFdsDFc8j1ciPm1gPMTg9z02dFdjyyI9sw/H4Ur1pldTOILOFXfqzay+2fKB4Mw0BxcXFsd2LJul5uxNx6gNnpYW76rMiOM+RkGwpAq9vNknVKWm6H2+omECUEpRRaW1v1ZsiTeECulRsxtx5gdnqYmz4rsuOAnGxDOZ2oLi1lyTolJadwotRTypJ1ojhQSqG6upoD8hhp5UbMrQeYnR7mps+K7HhkR7Zh+P0Ytnq11c0gskTwKutE1HOGYWDYsGGx3YkXddPLjZhbDzA7PcxNnxXZcYacbEMJgRaPB0oIq5tC1OcEBDxODwS4/RP1lFIKLS0tvKhbjLRyI+bWA8xOD3PTZ0V2HJCTbSjDQO348VD8TEVKQgYMjM8cD4N/tol6TCmF2tpalqzHSCs3Ym49wOz0MDd9VmTHknWyDSMQQNG6dVY3g8gSAQSwbh+3f6J4MAwDRUVFsd2JA3K93Ii59QCz08Pc9FmRHadayDaUEDg4YABL1ikpCQgMSBnAknWiOFBK4eDBg5whj5FWbsTceoDZ6WFu+qzIjgNysg1lGKgfOZIl65SUDBgYmTGSJetEcaCUQn19fWwHXMGLuiX5OeQx50bMrQeYnR7mps+K7FiyTrZhBAIoXL/e6mYQWSKAANZ7uf0TxYNhGCgsLIztTpwh18uNmFsPMDs9zE2fFdlxqoVsQwmBprw8lqxTUhIQyEvNY8k6URwopdDU1MSS9Rhp5UbMrQeYnR7mps+K7DggJ9tQQqChuJgDckpKAgLF6cUckBPFgVIKDQ0NHJDHSCs3Ym49wOz0MDd9VmTHknWyDUNKFGzcaHUziCwhIbHRy+2fKB4Mw0BBQUFsdwqeQ57EA3Kt3Ii59QCz08Pc9FmRHWfIyTaUEDhQWMgZckpKAgKFrkLOkBPFgVIKBw4c0JshT/KLusWcGzG3HmB2epibPiuy44CcbEMJgeb8fA7IKSkJCOSn5nNAThQHSik0NzezZD1GWrkRc+sBZqeHuemzIjuWrJNtGFIib/Nmq5tBZAkJic0HuP0TxYNhGMjLy4vtThyQ6+VGzK0HmJ0e5qbPiuw4Q062oQwD3mHD+DnklJQMGBiWNoyfQ04UB0opeL1ezpDHSCs3Ym49wOz0MDd9VmTHIzuyDQXA5/GAf1ooWXmcHqubQJQQlFLw+XyxHXAFL+qW5OeQx5wbMbceYHZ6mJs+K7JjyTrZhiElcj/91OpmEFlCQuLTRm7/RPFgGAZyc3NjuxNnyPVyI+bWA8xOD3PTZ0V2nCEn21CGgf3Dh7NknZKSAQPD04ezZJ0oDpRS2L9/P0vWY6SVGzG3HmB2epibPiuy45Ed2YYC4He5WLJOSctluKxuAlFCUErB7/dzQB4jrdyIufUAs9PD3PRZkR1L1sk2DCkxcNs2q5tBZAkJiW1N3P6J4sEwDAwcODC2OwXPIU/iAblWbsTceoDZ6WFu+qzIjjPkZBvKMFA/ciRL1ikpGTAwMmMkS9aJ4kAphfr6er0Z8iS/qFvMuRFz6wFmp4e56bMiOx7ZEREREXWHJetERNQLWLL+/9u7+/CoqgN/4N9zZ8gkhGRCICQhhAQFAqhEeYuIlYIoutZqy69SH7aLb7tbDa5KXVvt+lJ1n+j20bUoYp+u1fXZ+lLr2n18Y0XBuCqgjYIomAICCSEJCUkmb2SSmXN+fyRzySSTZObMkJvJ/X548nBm5s7MOd97k7lnzrn3UtwQUiK9vNzqahBZQkKivJ3bP1EsCCGQnp4e2ZPYIdfLjZhbFJidHuamz4rsOEJOcUMaBurnzIHklHWyIQMG5iTP4ZR1ohiQUqK+vh5SyvCfxA65Xm7E3KLA7PQwN31WZGfpnl1JSQkWLlyIlJQUTJo0CVdffTXK+4yAdnR0oLi4GBMmTMC4ceOwatUq1NbWWlRjspIA4PR6IayuCJFFvNJrdRWIRgUhBJxOJ4SI4BMlcFI3Gx9DrpUbMbcoMDs9zE2fFdlZ2iEvLS1FcXExduzYgS1btqCrqwuXXnop2trazGXuuOMOvPHGG3j11VdRWlqKY8eO4Yc//KGFtSarCCmRdvAgBL/tIxuSkDh48iAkuP0TRUsIgbS0tMh2uDhCrpcbMbcoMDs9zE2fFdlZ2iHfvHkzrrvuOpx11lkoLCzE888/j4qKCpSVlQEAPB4Pnn32WTz++ONYvnw55s+fj+eeew6ffPIJduzYYWXVyQLSMHB87lxOWSdbMmBg7ri5nLJOFANSShw/fpxT1iOklRsxtygwOz3MTZ8V2Y2oPTuPxwMA5oH0ZWVl6OrqwooVK8xlZs2ahalTp2L79u0hX8Pr9aK5uTnoB4AZqlLKPI29lDLycs+3JdLhOFV2OhE4MX7fMgCogcpCQDococs9nc6gsmEMWA5cCkwOVg7Ut3e5dztGeJsEgDEtLcAoalM8riej518kZdFzoEHvsgOOkGWnOHWuyUjKAgIOOEKWA3XpXdZph9VtavG1jLo2xdN6UkoFfZbEokzWEELA5XJxhDxCWrkRc4sCs9PD3PRZkd2I6ZBLKXH77bdjyZIlOPvsswEANTU1SEhIQFpaWtCymZmZqKmpCfk6JSUlcLvd5k9ubi4AoLGx0fw/UG5oaDC/BKivrzc773V1dWhtbQUA1NbWor29HQBQXV2Njp4vC6qWLIE3NRUAUHnRRehKTgYAVCxfDr/LBel0omL5ckinE36XCxXLlwMAupKTUXnRRQAAb2oqqpYsAQB0pKejuqgIANA+aRJqFy4EALROnoy6884DADTn5qK+JxvPtGlomDWru00zZqBxxozuNs2aBc+0ad1tOvtsNPe0v+6889A6eXJ3mxYuRPukSd1tKiqKmzYJKdGVkoKWnJxR06Z4XE/TkqZhVnJ3m2aMnYEZY7vbNCt5FqYldbfp7HFnIzexu03npZyHya7uNi10L8SkhO42FbmLkD6mu01Lxi9BqrO7TReNvwjJju42LU9fDpfhglM4sTx9OZzCCZfhwvL07jYlO5Jx0fjuNqU6U7FkfHeb0seko8jd3aZJCZOw0N3dpsmuyTgvpbtNuYm5OHtc/LQpbUwasl3ZkJCjpk3xtp78fj8qKioAAF1dXaisrATQ/UVwVVUVgO7znlRXVwMA2tvbzXOetLa2oq6uDgDQ3NyMEydOgKwjhIDb7dY7htzmHfKIcyPmFgVmp4e56bMiO6FGyBXjb775Zrzzzjv46KOPMGXKFADAiy++iOuvvx5eb/CJjBYtWoRly5bh0Ucf7fc6Xq83aPnm5mbk5uaisbERaWlp5mi3EAJSSgghIis7nRBKQTocEFJ2l51OCJ8PAuhXNnw+KAAqVFkIKMOA4ff3LwsBo2dE3iwbBhQQsgx0H2Mte0aSQ5aV6q5v73LvdozwNikAx+fNQ8auXXD4fKOiTfG2nhz3SXP0USL8sur517vsgAMSsl/ZKZzwqe6TJkVSDoyq+uHvVxYQkJBBZZ12WNkmBxyYlzIPZS1lUFCjok3xtp7kfd0zpgzDMGdb6ZY9Hg/Gjx8Pj8eD1J4v2Ehfc3Mz3G532HlKKVFXV4eMjAwY4R4G9dZbwPe+ByxYAHz2WZQ1jk9auRFziwKz08Pc9MUyu3A/m0bEdcjXrVuHN998Ex9++KHZGQeArKwsdHZ2oqmpKWiUvLa2FllZWSFfy+VyweVy9bs/EGjvbzt6hxx2uadDb/j9p+7vdcbVUGUBQIQqKwXR8zr9yoEvDnqXpTTPMN63bL5npOXe7RjpbRICydXVZj1HRZvCLY+gNvU+qVg0ZT/8IcuBTlCkZQVlvk7fsuqZzN+7HKt2DFebJCSOdR4z2zAa2hRv6ynw5WwsytxBspYQAmPHjuWU9Qhp5UbMLQrMTg9z02dFdpbuESilsG7dOrz++uvYunUrpvVM4Q2YP38+xowZg/fff9+8r7y8HBUVFVi8ePFwV5csJpRCSlWV2UkkshMFhSpvldlRJSJ9QgikpKSwQx4hrdyIuUWB2elhbvqsyM7SDnlxcTH+67/+Cy+++CJSUlJQU1ODmpoanDx5EgDgdrtx4403Yv369di2bRvKyspw/fXXY/HixTj//POtrDpZQBoGqouKeJZ1siUDBorcReaUbCLSJ6VEdXU1z7IeIa3ciLlFgdnpYW76rMjO0inrmzZtAgB897vfDbr/ueeew3XXXQcA+Pd//3cYhoFVq1bB6/Vi5cqVePrpp4e5pjQSCKWQevgwR8jJlhQUDp88zBFyohgQQiA1NVXvpG69Dg+yG63ciLlFgdnpYW76rMjO0g55OOeTS0xMxMaNG7Fx48ZhqBGNZEIpJPecsZjIbhQUaju5/RPFghACyT1XqAgbR8j1ciPmFgVmp4e56bMiO859pLghHQ5UXXCBec1sIjtxwIEL3BeY1+0mIn1SSlRVVXHKeoS0ciPmFgVmp4e56bMiO3bIKW4IKZFeXh50tnIiu5CQKG8vDzpbOBHpEUIgPT2dJ3WLkFZuxNyiwOz0MDd9VmQ3Ii57RhQOoRSSTpywuhpEllBQONHF7Z8oFoQQSEpKiuxJ7JDr5UbMLQrMTg9z02dFdhwhp7ghHQ5UXnQRp6yTLTngwEXjL+KUdRqVHnjgAfNa7YGfWbNmnbb3k1KisrIysimJPKmbXm7E3KLA7PQwN31WZMcRcoobQkpk7N7NKetkSxISu1t2c8o6jVpnnXUW3nvvPfO203n6dlGEEMjIyOCU9Qhp5UbMLQrMTg9z02dFduyQU9wQSiHR47G6GkSWUFDw+Lj90+jldDqRlZU1LO8lhEBiYmJkTwp0yH0+QCnAhju6WrkRc4sCs9PD3PRZkR2nrFPckE4njixfDnkaR02IRiqncGJ5+nI4Bbd/Gp3279+PyZMn44wzzsCaNWtQUVEx4LJerxfNzc1BPwDMKYZKKfPSqlLKfmUpJQ4fPgy/3z/gMv3KvQ6Xkp2dQcsE3vN0l4esYwzLod7f5/PhyJEj8Pv9o6ZNw7GetLa3Ed6m4VpPgex8PYeKjIY2Dcd68vl8OHz4sJnhaGjTcK0nv9+PQ4cOBf3+RtuOobBDTnFD+HzI3rkTwsbH75F9+ZQPOz074VPc/mn0KSoqwvPPP4/Nmzdj06ZNOHToEL7zne+gpaUl5PIlJSVwu93mT25uLgCgsbHR/D9QbmhogKdndlV9fT2am5shhIDT6URbWxsAoLa2Fu3t7QCA6upqdHR0AACqqqrg9XoBAEdrasz3rzx0yOyUVlRUQEoJv99vfonQ1dWFyspKAN1fHlRVVQEAOjo6UF1dDQBob29HbW0tAKC1tRV1dXUAgObmZtTX1wMAPB4PGhoawmoTANTV1aG1tTXsNlVWVqKrZwp+RUXFkG2qqqpCdnY2Ojs7R02bhmM9CSGQkJBgbs+joU3DtZ4C04cD7RgNbRqO9dTU1ITk5GQIIUZNm4ZrPQXaJYSIuk0nwjwZtVCBrwVGqebmZrjdbng8HqSmpkb/gjacokYUIB6wugZE1lH3x+7jMuafTaNMU1MT8vLy8Pjjj+PGG2/s97jX6zV3roDuPHNzc9HY2Ii0tDRzxEMIASmleaK4qMrt7TCSkwEAsrERwu02lzEMwxzJOZ3lmLdpkDLbxDaxTWwT2xRd2ePxYPz48UN+1nOEnOKGdDpx+NJLOWWdbMkpnLh0wqWcsk62kJaWhpkzZ+LAgQMhH3e5XEhNTQ36AQDD6N6tCexgBe7rWw6MhgR29kIt06/scpnvb/SMnvR9z9NdHrKOMSyHen8AOHz4sLnDORraNBzrSWt7G+FtGq71JKXEkSNHEDAa2jQc6wkAjhw5YnYyR0Obhms9KaXM0fJYtWMo7JBT3BA+H6aUlnLKOtmST/lQ2ljKKetkC62trTh48CCys7NPy+sLITBlypSgndchORynZsnZ9EzrWrkRc4sCs9PD3PRZkR075BQ3BHpGJayuCJFF/MpvdRWITos777wTpaWlOHz4MD755BP84Ac/gMPhwLXXXnta3i8wchHxDpfNL32mnZvNMTd9zE4Pc9NnRXbskFPckE4nKniWdbIpnmWdRrOjR4/i2muvRUFBAa655hpMmDABO3bsQEZGxml5v94n8IlI4PPHpjO1tHOzOeamj9npYW76rMiOe3YUNwyfD1O3boVh0x0hsjef8mFrw1ZOWadR6eWXXx7W9zMMA1OnTg37+D6TzUfItXOzOeamj9npYW76rMiOa4nihkL3dWBH9WUBiAbhEI6hFyKiISmlgq4/Gzabd8i1c7M55qaP2elhbvqsyI4dcoobyunE0aVLoThlnWzIKZxYOn4pp6wTxYBSCkePHmWHPELaudkcc9PH7PQwN31WZMc9O4obhs+H/HfftboaRJbwKR/ePcHtnygWDMNAfn5+5E+0+THk2rnZHHPTx+z0MDd9VmTHEXKKGwpAZ3Iyp6yTbSU7kq2uAtGooJRCZ2cnR8gjpJ2bzTE3fcxOD3PTZ0V27JBT3FBOJ6qLijhlnWzJKZwochdxyjpRDCilUF1dzQ55hLRzsznmpo/Z6WFu+qzIjnt2FDcMnw95W7daXQ0iSwTOsk5E0TMMA3l5eZE/0eYdcu3cbI656WN2epibPiuy4wg5xQ0lBDrcbighrK4K0bATEHA73RDg9k8ULaUUOjo6OEIeIe3cbI656WN2epibPiuyY4ec4oYyDNQVFkLxmopkQwYMFKYUwuCfbaKoKaVQV1cXcofr7f1v4xfv/QK7a3b3f6LNT+o2WG40MOamj9npYW76rMiOU9Ypbhh+P3I//NDqahBZwg8/Pmzk9k8UC4ZhIDc3N+Rjv/v8d/jzN39G1rgsFGYVBj9o8xHywXKjgTE3fcxOD3PTZ0V2HGqhuKGEwMkJEzhlnWxJQGDCmAmcsk4UA0opnDx5MuQIyLyseQCAz6s/7/9Em3fIB8uNBsbc9DE7PcxNnxXZsUNOcUMZBhoKCjhlnWzJgIGCsQWcsk4UA0opNDQ0hNzhOi/7PADAFzVf9H8iO+QD5kYDY276mJ0e5qbPiuw4ZZ3ihuH3I+eTT6yuBpEl/PDjEw+3f6JYMAwDOTk5IR87L6u7Q76vbh9Odp1E0pikUw/a/BjywXKjgTE3fcxOD3PTZ0V2HGqhuKGEQFtmJqesky0JCGQmZHLKOlEMKKXQ1tYWcgRkcspkTEqeBL/yY8/xPcEPcoR8wNxoYMxNH7PTw9z0WZEdO+QUN5QQaM7PZ4ecbElAID8pnx1yohhQSqG5uTnkDpcQwhwl/6K6z7R1dsgHzI0Gxtz0MTs9zE2fFdmxQ05xw5AS2Tt3wpDS6qoQDTsJiZ2enZDg9k8ULcMwkJ2dDWOAc5LMyx7gxG4275APlRuFxtz0MTs9zE2fFdlxLVHcUEKgJSeHI+RkSwICOa4cjpATxYBSCi0tLQOOgJgj5H1P7GbzDvlQuVFozE0fs9PD3PRZkR075BQ3lBBoz8pih5xsSUAgKyGLHXKiGFBKob29feAOec+Z1r+s/RJd/l6db5uf1G2o3Cg05qaP2elhbvqsyI4dcoobhpTILCvjlHWyJQmJspYyTlknigHDMJCZmTnglMQzxp+BVFcqvH4vvqn/5tQDNh8hHyo3Co256WN2epibPiuy41qiuKEMA568PF6HnGzJgIG8xDxeh5woBpRS8Hg8A46AGMLAuVnnAugzbd3mHfKhcqPQmJs+ZqeHuemzIjvu2VHcUAC8bjf4p4Xsyu10W10FolFBKQWv1zvoDlfgOPKgE7uxQz5kbtQfc9PH7PQwN31WZOcctnciipIhJSZ9+aXV1SCyhITEl63c/oliwTAMTJo0adBlAmdaDzlCbtNjyMPJjfpjbvqYnR7mps+K7DhCTnFDGQaazjyTU9bJlgwYODPpTE5ZJ4oBpRSamprCGiH/ovoLSNVz7obASd1sPEI+VG7UH3PTx+z0MDd9VmTHPTuKGwqAz+XilHWyLZfhsroKRKOCUgo+n2/QHa7ZGbOR6ExES2cLvm38tvtOTlkfMjfqj7npY3Z6mJs+K7Jjh5zihiElJu7dy7Osky1JSOxt28uzrBPFgGEYmDhx4qBn0XUaTpwz6RwA3aPkAGzfIQ8nN+qPueljdnqYmz4rsuNaorihDAMNBQWcsk62ZMBAwdgCTlknigGlFBoaGoYcAel3Yjebd8jDzY2CMTd9zE4Pc9NnRXbcsyMiIiIKod+J3QLHkNv0pG5ERBR7PMs6xQ0hJdLLy62uBpElJCTK27n9E8WCEALp6elDLnde9qkRcqUUhM1HyMPNjYIxN33MTg9z02dFdhwhp7ghDQP1c+ZAcso62ZABA3OS53DKOlEMSClRX18POcQ5Sc6ZdA4cwoG69jocazlm+ynr4eZGwZibPmanh7npsyI77tlR3BAAnF4vhNUVIbKIV3qtrgLRqCCEgNPphBCDf6IkjUnC7IzZAHqmrdu8Qx5ubhSMueljdnqYmz4rsmOHnOKGkBJpBw9C8Ns+siEJiYMnD/Is60QxIIRAWlpaWDtcQSd2C3TIbXoMeSS50SnMTR+z08Pc9FmRHTvkFDekYeD43Lmcsk62ZMDA3HFzOWWdKAaklDh+/HhYUxKDTuwWOKmbTUfII8mNTmFu+pidHuamz4rsuGdHcUMAcHk8nLJOtuXxeayuAtGoIISAy+WKaIT8i2pOWY8kNzqFueljdnqYmz4rsmOHnOKGkBLuI0c4ZZ1sSULiSMcRTlknigEhBNxud1g7XOdmnQsAOOI5ghOio/tOG3fIw82NTmFu+pidHuamz4rs2CGnuCENA7Xz53PKOtmSAQPzU+ZzyjpRDEgpUVtbG9aURHeiG2eOPxMAsKursvtOm3bII8mNTmFu+pidHuamz4rsuGdHcUMohbE1NRBKWV0VomGnoFDTWQMFbv9E0RJCYOzYsWGPgJjXI/ce6r7Dxid1iyQ36sbc9DE7PcxNnxXZsUNOcUMohZSqKnbIyZYUFKq8VeyQE8WAEAIpKSnhd8gDx5Gf7OmQ23SEPNLcqBtz08fs9DA3fVZkxw45xQ1pGKguKuKUdbIlAwaK3EWcsk4UA1JKVFdXhz0l0TzTevvB7jts2iGPNDfqxtz0MTs9zE2fFdlxz47ihlAKqYcPc4ScbElB4fDJwxwhJ4oBIQRSU1MjHiEvb69EawJs2yGPNDfqxtz0MTs9zE2fFdmxQ05xQyiF5NpadsjJlhQUajtr2SEnigEhBJKTk8Pe4cocl4nJKZOhoPBlJmx9DHkkuVE35qaP2elhbvqsyI4dcoob0uFA1QUXQDocVleFaNg54MAF7gvgALd/omhJKVFVVRXRlMTAKPnn2bDtCLlObsTcosHs9DA3fVZkxw45xQ0hJdLLy3kdcrIlCYny9nJeh5woBoQQSE9Pj2gExDyxWxZs2yHXyY2YWzSYnR7mps+K7JzD9k5EURJKIenECaurQWQJBYUTXdz+iWJBCIGkpKSInmOe2M3GI+Q6uRFziwaz08Pc9FmRHUfIKW5IhwOVF13EKetkSw44cNH4izhlnSgGpJSorKyMbMp6z7XIv5oEdPo7T1fVRjSd3Ii5RYPZ6WFu+qzIjh1yihtCSmTs3s0p62RLEhK7W3ZzyjpRDAghkJGREdGUxDx3HsYnuNHlAL4eb98R8khzI+YWDWanh7npsyI7dsgpbgilkOjx8CzrZEsKCh6fh2dZJ4oBIQQSExMj2uESQuC8iecAAL6YaN+zrEeaGzG3aDA7PcxNnxXZsUNOcUM6nTiyfDmkk6c+IPtxCieWpy+HU3D7J4qWlBJHjhyJeErieZPmAgA+z1KADWdr6eZmd8xNH7PTw9z0WZEdO+QUN4TPh+ydOyFsev1Xsjef8mGnZyd8its/UbSEEMjOzo54BGSezc+0rpub3TE3fcxOD3PTZ0V2HGqhuCEAJLS1WV0NIsu0+bn9E8WCEAIJCQkRP++8yd1nWt+VBfg7vXC4XLGu2oimm5vdMTd9zE4Pc9NnRXbskFPckE4nKpYvx9StW2FwlJxsJjBlfWvDVo6SE0VJSomKigpMnToVhhH+ZMGZGbMxthNoTwDOem4BnM4EcxRFoOf/Prd732feHmDZwG2lFBQUpJIhy4HnCCFC/j/Qc6WS5vsEljeEEfI1guobqL8COjs7kZCQEHQ+i8HObdH3tQajoMw6925r7/JQrz9QJuGsl8B79W6TCnHemqHWW6j/O7s6kTAmYdD6hZNV7/fuW4++dQ51e6j29a5H3zqF8/p9cxyo/r3r3Vu/9axgZjdQPEPlFmi3VDJovZi/DyF+F3qXB1uvQ7VtoPaG2h5Dtm2I1wy1LhRUUG5CDPz7EOr3bKB1FyrT3uW+v7eBOg/0d2agNgS1v8923nubHGydDPY3aaB6976vcHwhXrr2pYg+H6LBDjnFDeHzYUppKaesky35lA+ljaXsjBPFgBACU6ZMiXhKosOViO8eBt6eCZQ37j89lSMiIktNSY388yEa7JBT3BAADL8/gu/aiUYXv/JbXQWiUUEIAcMwIt/hEgJ//G8Df8mUkH/6I9SECQAGH1XtO1Iz1OiiUmrA0TpDGEOO2CmooGX7lgPP7z1a2HfkMFR9A3VUSsEQhpmjGU0Yo52BtgVFGsYId2C5vs/tO5I3WCaDjbL3rdtgsx1CjaYFyoPOWuh5/YFG/8Mdlez9nN7loWZdDHW7d56hts2hRnfDnYHQ+3VDvXao50kpBxypDLUN9H081Aht79+JwGj5QL8Xg63X3iPNfesQTt2ifbzvjAbg1O+KlLLfNtd32xno9yzc2Rp9Z1P0/TvTd0ZC7/uG+lsw0Ch8qLoPtm5C1n2Aegfucye42SEnCoVT1snOOGWdKHZ0p6wDQDISsPRIB5CxCMjLO001HJmiyc3OmJs+ZqeHuekLZDfYF0GxxjVEccPw+dgZJ9vyKR8740QxYhiG/o7qmDHd/9vwsyiq3GyMueljdnqYmz4rsuNaorihAEiHY5AJZ0Sjm0M4rK4C0aiglIKUMqxpwv04eyYX2vCyZ1HlZmPMTR+z08Pc9FmRHTvkFDeU04mjS5dCOXmkBdmPUzixdPxSOAW3f6JoKaVw9OhRvR2uwAi5TTvk2rnZGHPTx+z0MDd9VmTHPTuKG4bPh/x337W6GkSW8Ckf3j3B7Z8oFgzDQH5+vt6Tbdwhjyo3G2Nu+pidHuamz4rsOEJOcUMB6ExO5pR1sq1kR7LVVSAaFZRS6OzsjG6E3IbHkEeVm40xN33MTg9z02dFduyQU9xQTieqi4o4ZZ1sySmcKHIXcco6UQwopVBdXc1jyCMUVW42xtz0MTs9zE2fFdlxz47ihuHzIW/rVqurQWSJwFnWiSh6hmEgT/eSZYER8q1bgdra0Mso1f0Tqqyj7/Vwh7rdux593zdQn771C1W3wOv2/G8IgTwhgO3bB69v3/cdrN2DtaXP+w/4PpEI9fqx0DfjXv8bAGJygbyh1vtA6zaS1xIidLn3aw/0+n3XV+/nazKzG2qbC9Sn9//h0v396vtefd93qNs6dQlT2NtcuL9bg90eLIO+28JQv9N9Xyfc94nUIO9vAMjLyhrWy1qyQ05xQwkBb2oqXM3NEPzGj2xGQCDVmYpmXzMUD9wgiopSCl6vFy6XCyLSHd6kpO7/77sv9hUjIiLL+Zcvh7F8eeSfD5rYIae4oQwDdYWFyPn4Ywi/3+rqEA0rAwYKUwrxcePH8IPbP1E0lFKoq6tDTk5O5Dtcd98NPPkkIOVgbxB6RCicEcOhvnAOZ+QqnBG/oeoWYjRKKQVvRwdciYkI2Yq+7z3UaHSkI4rhtC2S1xvqtSM1wOi+AgbPbaD6DHa772ODjUSGGkkPdXuwmR29XzfU64eaFRHuiPUguQ+Z3UDbXLjr8nSMag/0WLS/D0Mt3/shaGxzfUUycyBUeaBZOIHyUOso0pkLuuu838MKbdOnY5xS7JAT9WX4/cj98EOrq0FkCT/8+LCR2z9RLBiGgdzcXL0n/7//1/1jQwJAotWViEPMTR+z08Pc9AkAqcP8njypG8UNJQROTpgANUzfVhGNJAICE8ZMgND/rpuIeiilcPLkSZ7wKELMTQ9z08fs9DA3fVZkxw45xQ1lGGgoKIAyuNmS/RgwUDC2AAb/bBNFTSmFhoYG7qxGiLnpYW76mJ0e5qbPiuw4ZZ3ihuH3I+eTT6yuBpEl/PDjEw+3f6JYMAwDOTk5Vlcj7jA3PcxNH7PTw9z0WZEdh1oobigh0JaZySnrZEsCApkJmZyyThQDSim0tbVx9ChCzE0Pc9PH7PQwN31WZMcOOcUNJQSa8/PZISdbEhDIT8pnh5woBpRSaG5u5s5qhJibHuamj9npYW76rMiOU9YpbhhSInvnTqurQWQJCYmdHm7/RLFgGAays7OtrkbcYW56mJs+ZqeHuemzIjuOkFPcUEKgJSeHI+RkSwICOa4cjpATxYBSCi0tLRw9ihBz08Pc9DE7PcxNnxXZsUNOcUMJgfasLHbIyZYEBLISstghJ4oBpRTa29u5sxoh5qaHueljdnqYmz4rsuOUdYobhpTILCuzuhpElpCQKGvh9k8UC4ZhIDMz0+pqxB3mpoe56WN2epibPiuy4wg5xQ1lGPDk5fE65GRLBgzkJebxOuREMaCUgsfj4ehRhJibHuamj9npYW76rMiOe3YUNxQAr9sN/mkhu3I73VZXgWhUUErB6/VyZzVCzE0Pc9PH7PQwN31WZMcp6xQ3DCkx6csvra4GkSUkJL5s5fZPFAuGYWDSpElWVyPuMDc9zE0fs9PD3PRZkR1HyCluKMNA05lncso62ZIBA2cmnckp6zSqbdy4Efn5+UhMTERRURE+/fTT0/I+Sik0NTVx9ChCzE0Pc9PH7PQwN31WZMc9O4obCoDP5eKUdbItl+GyugpEp80rr7yC9evX4/7778fnn3+OwsJCrFy5EsePH4/5eyml4PP5uLMaIeamh7npY3Z6mJs+K7Jjh5zihiElJu7dC0NKq6tCNOwkJPa27YUEt38anR5//HH8/d//Pa6//nrMmTMHzzzzDMaOHYvf//73MX8vwzAwceJEGJxxFRHmpoe56WN2epibPiuyi4u1NFxT2GhkU4aBhoICTlknWzJgoGBsAaes06jU2dmJsrIyrFixwrzPMAysWLEC27dv77e81+tFc3Nz0A8AyJ4vbJVS5uiGlLJfWSmFEydOmMuHWiaScuA9T3c5mjrGok1+vx8NDQ2QUo6aNg3Heor19jYS2jRc6ymQnd/vHzVtGo715Pf7ceLEiaAc471Nw7WepJSor6833zsW7RjKiN+zG84pbERERDT86uvr4ff7+137NTMzEzU1Nf2WLykpgdvtNn9yc3MBAI2Njeb/gXJDQwM8Ho/5PoHOe2NjI1pbWwEAtbW1aG9vBwBUV1ejo6MDAFBVVQWv1wsAqKysRFdXFwCgoqICfr8fUkpUVFRASgm/34+KigoAQFdXFyorKwF0f3lQVVUFAOjo6EB1dTUAoL29HbW1tQCA1tZW1NXVAQCam5tRX18PAPB4PGhoaAi7TXV1dae1TUePHh11bRqu9dTU1DTq2jRc68nn83Hbi7BNvf++jZY2Ded6CtQx2jadOHEC4RAq8LXACFVUVISFCxfiqaeeAtD9rUVubi5uvfVW/OIXvxjy+c3NzXC73fB4PEhNTY2+QkJE/xpEcUo8YHUNiKyj7o/dx2XMP5vi3LFjx5CTk4NPPvkEixcvNu+/6667UFpaip07dwYt7/V6zZ0roDvP3NxcNDY2Ii0tzRzxEEJASgkhxGktG4ZhjqaczjLbxDaxTWwT2xQ/bfJ4PBg/fvyQn/Uj+rJngSlsd999t3nfYFPYgP4f0r2/mQQQ/YoFIABIw4DouS0dDgi/P2TZ8PuhAKiByoYBQ8r+ZSFgKBVcFgIKCFkGAKEUpBDddQxVVqq7Xr3LvdsxwtukADTMmoXxf/0rHH7/qGhTvK0ndCh01xZQCL+sek7F17tswDCPh+5ddggH/MqvVR7oNUPVQacdVrbJgIGC5AJ80/bNgHWItzbF23ryeDwx/ZAGTn0m2d3EiRPhcDjMUYaA2tpaZGVl9Vve5XLB5Tp1ksNAjq2trWEd9yelRGNjI8aPH89jLCPA3PQwN33MTg9z0xfL7AIj90N91o/oDvlgU9i++eabkM8pKSnBr371q3735+XlxbZyvY8J6DmuRavc+3V6l3uvuEA51H3Rlgd6/5Hapn37hl4m3toUT+vpEZidGiC6cu+Tk/Uu++HXLg/0mqHqEKt2DFebJCT24dT2Pxra1Lc80tuU9kgaYq2lpQVutzvmrxtvEhISMH/+fLz//vu4+uqrAXTvFL3//vtYt27dkM9vaWkBAHPqOhER0Ugx1Gf9iO6Q67j77ruxfv1687aUEg0NDZgwYQKE4HTzeBaYklhZWckpnmQ73P5HF6UUWlpaMHnyZKurMmKsX78ea9euxYIFC7Bo0SI88cQTaGtrw/XXXz/kcydPnozKykqkpKSE9VnP3yc9zE0Pc9PH7PQwN32xzC7cz/oR3SGPdAob0H8aGwCkpaWdriqSBVJTU/nHhWyL2//owZHxYKtXr0ZdXR3uu+8+1NTU4Nxzz8XmzZv7zZILxTAMTJkyJeL35O+THuamh7npY3Z6mJu+WGUXzmf9iD6ooPcUtoDAFLbeJ30hIiKi+Ldu3TocOXIEXq8XO3fuRFFRkdVVIiIiOq1G9Ag5EN0UNiIiIiIiIqKRasR3yKOZwkaji8vlwv3339/vkAQiO+D2TxQ7/H3Sw9z0MDd9zE4Pc9NnRXYj/jrkRERERERERKPRiD6GnIiIiIiIiGi0YoeciIiIiIiIyALskBMRERERERFZgB1yGvUOHz4MIQR27doFAPjggw8ghEBTU5Ol9SIiIiIiIntjh5xipqamBrfeeivOOOMMuFwu5Obm4sorrwy6jrwVcnNzUV1djbPPPtvSehD1dd1110EI0e/nwIED2q/JL5yIBrdx40bk5+cjMTERRUVF+PTTT62u0ojz4Ycf4sorr8TkyZMhhMCf//znoMeVUrjvvvuQnZ2NpKQkrFixAvv377emsiNISUkJFi5ciJSUFEyaNAlXX301ysvLg5bp6OhAcXExJkyYgHHjxmHVqlWora21qMYjw6ZNmzB37lykpqYiNTUVixcvxjvvvGM+zszC88gjj0AIgdtvv928j9mF9sADD/Tb95o1a5b5+HDnxg45xcThw4cxf/58bN26Fb/+9a+xZ88ebN68GcuWLUNxcbGldXM4HMjKyoLTOeKv8kc2dNlll6G6ujroZ9q0aVZXi2hUeuWVV7B+/Xrcf//9+Pzzz1FYWIiVK1fi+PHjVldtRGlra0NhYSE2btwY8vF/+7d/w4YNG/DMM89g586dSE5OxsqVK9HR0THMNR1ZSktLUVxcjB07dmDLli3o6urCpZdeira2NnOZO+64A2+88QZeffVVlJaW4tixY/jhD39oYa2tN2XKFDzyyCMoKyvDX/7yFyxfvhxXXXUVvv76awDMLByfffYZfvvb32Lu3LlB9zO7gZ111llB+14fffSR+diw56aIYuDyyy9XOTk5qrW1td9jjY2NSimljhw5or7//e+r5ORklZKSon70ox+pmpoac7n7779fFRYWqmeffVbl5uaq5ORkdfPNNyufz6ceffRRlZmZqTIyMtTDDz8c9PoA1NNPP60uu+wylZiYqKZNm6ZeffVV8/FDhw4pAOqLL75QSim1bds2BcCsl1JK/d///Z+68MILVWJiopoyZYq69dZbQ7aFKJbWrl2rrrrqqn73P/bYY+rss89WY8eOVVOmTFE333yzamlpMR8/fPiw+t73vqfS0tLU2LFj1Zw5c9Rbb71lbuu9f9auXTt8DSIa4RYtWqSKi4vN236/X02ePFmVlJRYWKuRDYB6/fXXzdtSSpWVlaV+/etfm/c1NTUpl8ulXnrpJQtqOHIdP35cAVClpaVKqe6cxowZE7SPsm/fPgVAbd++3apqjkjjx49X//Ef/8HMwtDS0qJmzJihtmzZopYuXapuu+02pRS3t8EE+hyhWJEbR8gpag0NDdi8eTOKi4uRnJzc7/G0tDRIKXHVVVehoaEBpaWl2LJlC7799lusXr06aNmDBw/inXfewebNm/HSSy/h2WefxRVXXIGjR4+itLQUjz76KP7lX/4FO3fuDHrevffei1WrVmH37t1Ys2YNfvzjH2Pfvn1h1f/gwYO47LLLsGrVKnz55Zd45ZVX8NFHH2HdunX6oRBFwTAMbNiwAV9//TX+8z//E1u3bsVdd91lPl5cXAyv14sPP/wQe/bswaOPPopx48YhNzcXr732GgCgvLwc1dXV+M1vfmNVM4hGlM7OTpSVlWHFihXmfYZhYMWKFdi+fbuFNYsvhw4dQk1NTVCObrcbRUVFzLEPj8cDAEhPTwcAlJWVoaurKyi7WbNmYerUqcyuh9/vx8svv4y2tjYsXryYmYWhuLgYV1xxRVBGALe3oezfvx+TJ0/GGWecgTVr1qCiogKANblxDi9F7cCBA1BKBR170df777+PPXv24NChQ8jNzQUAvPDCCzjrrLPw2WefYeHChQAAKSV+//vfIyUlBXPmzMGyZctQXl6Ot99+G4ZhoKCgAI8++ii2bduGoqIi8/V/9KMf4aabbgIAPPTQQ9iyZQuefPJJPP3000PWv6SkBGvWrDGPuZkxYwY2bNiApUuXYtOmTUhMTNSNhmhIb775JsaNG2fevvzyy/Hqq6+at/Pz8/Hwww/jpz/9qbk9V1RUYNWqVTjnnHMAAGeccYa5fGDHb9KkSUhLSxuGFhDFh/r6evj9fmRmZgbdn5mZiW+++caiWsWfmpoaAAiZY+Ax6t6fuf3227FkyRLzHDY1NTVISEjo97eZ2QF79uzB4sWL0dHRgXHjxuH111/HnDlzsGvXLmY2iJdffhmff/45Pvvss36PcXsbWFFREZ5//nkUFBSguroav/rVr/Cd73wHX331lSW5sUNOUVNKDbnMvn37kJuba3bGAWDOnDlIS0vDvn37zA55fn4+UlJSzGUyMzPhcDhgGEbQfX2P91u8eHG/24Gzqg9l9+7d+PLLL/GHP/whqE1SShw6dAizZ88O63WIdCxbtgybNm0ybycnJ+O9995DSUkJvvnmGzQ3N8Pn86GjowPt7e0YO3Ys/umf/gk333wz3n33XaxYsQKrVq3qd9wYERFZp7i4GF999VXQcak0sIKCAuzatQsejwd/+tOfsHbtWpSWllpdrRGtsrISt912G7Zs2cLBowhdfvnlZnnu3LkoKipCXl4e/vjHPyIpKWnY68Mp6xS1GTNmQAgRkxGGMWPGBN0WQoS8T0oZ9XsFtLa24h//8R+xa9cu82f37t3Yv38/zjzzzJi9D1EoycnJmD59uvnj9Xrxve99D3PnzsVrr72GsrIy88RKnZ2dAICbbroJ3377LX7yk59gz549WLBgAZ588kkrm0E04k2cOBEOh6PfmXJra2uRlZVlUa3iTyAr5jiwdevW4c0338S2bdswZcoU8/6srCx0dnb2uwoGswMSEhIwffp0zJ8/HyUlJSgsLMRvfvMbZjaIsrIyHD9+HPPmzYPT6YTT6URpaSk2bNgAp9OJzMxMZhemtLQ0zJw5EwcOHLBkm2OHnKKWnp6OlStXYuPGjUFnEg1oamrC7NmzUVlZicrKSvP+vXv3oqmpCXPmzIm6Djt27Oh3O9yR7Xnz5mHv3r1BnaLAT0JCQtR1I4pEWVkZpJR47LHHcP7552PmzJk4duxYv+Vyc3Px05/+FP/93/+Nn/3sZ/jd734HAOY26/f7h7XeRCNdQkIC5s+fH3QpTikl3n///X6zrGhg06ZNQ1ZWVlCOzc3N2Llzp+1zVEph3bp1eP3117F169Z+V8yYP38+xowZE5RdeXk5KioqbJ9dX1JKeL1eZjaIiy++GHv27AkaUFqwYAHWrFljlpldeFpbW3Hw4EFkZ2dbss1xyjrFxMaNG7FkyRIsWrQIDz74IObOnQufz4ctW7Zg06ZN2Lt3L8455xysWbMGTzzxBHw+H2655RYsXboUCxYsiPr9X331VSxYsAAXXngh/vCHP+DTTz/Fs88+G9Zzf/7zn+P888/HunXrcNNNNyE5ORl79+7Fli1b8NRTT0VdN6JITJ8+HV1dXXjyySdx5ZVX4uOPP8YzzzwTtMztt9+Oyy+/HDNnzkRjYyO2bdtmfgGVl5cHIQTefPNN/M3f/A2SkpKCjlEnsrP169dj7dq1WLBgARYtWoQnnngCbW1tuP76662u2ojS2tqKAwcOmLcPHTqEXbt2IT09HVOnTsXtt9+Ohx9+GDNmzMC0adNw7733YvLkybj66qutq/QIUFxcjBdffBH/8z//g5SUFPN4U7fbjaSkJLjdbtx4441Yv3490tPTkZqailtvvRWLFy/G+eefb3HtrXP33Xfj8ssvx9SpU9HS0oIXX3wRH3zwAf73f/+XmQ0iJSXFPD9BQHJyMiZMmGDez+xCu/POO3HllVciLy8Px44dw/333w+Hw4Frr73Wmm3utJy7nWzp2LFjqri4WOXl5amEhASVk5Ojvv/976tt27YppcK/7FlvoS4L1fuSDkp1X5Jl48aN6pJLLlEul0vl5+erV155xXw8nMueffrpp+qSSy5R48aNU8nJyWru3LnqX//1X2MRC9GABrrs2eOPP66ys7NVUlKSWrlypXrhhReCttl169apM888U7lcLpWRkaF+8pOfqPr6evP5Dz74oMrKylJCCF72jKiPJ598Uk2dOlUlJCSoRYsWqR07dlhdpREn8DnZ9yfw90RKqe69916VmZmpXC6Xuvjii1V5ebm1lR4BQmUGQD333HPmMidPnlS33HKLGj9+vBo7dqz6wQ9+oKqrq62r9Ahwww03mPuOGRkZ6uKLL1bvvvuu+TgzC1/ffWRmF9rq1atVdna22V9ZvXq1OnDggPn4cOcmlArjjFxEI5gQAq+//rrtv5knIiIiIqL4wmPIiYiIiIiIiCzADjkRERERERGRBXhSN4p7POqCiIiIiIjiEUfIiYiIiIiIiCzADjkRERERERGRBdghJyIiIiIiIrIAO+REREREREREFmCHnIiIiIiIiMgC7JATEREREZG2Dz74AEIINDU1WV0VorjDDjkRERERERGRBdghJyIiIiIiIrIAO+RERERERHFMSomSkhJMmzYNSUlJKCwsxJ/+9CcAp6aTv/XWW5g7dy4SExNx/vnn46uvvgp6jddeew1nnXUWXC4X8vPz8dhjjwU97vV68fOf/xy5ublwuVyYPn06nn322aBlysrKsGDBAowdOxYXXHABysvLT2/DiUYBdsiJiIiIiOJYSUkJXnjhBTzzzDP4+uuvcccdd+Bv//ZvUVpaai7zz//8z3jsscfw2WefISMjA1deeSW6uroAdHekr7nmGvz4xz/Gnj178MADD+Dee+/F888/bz7/7/7u7/DSSy9hw4YN2LdvH377299i3LhxQfX45S9/icceewx/+ctf4HQ6ccMNNwxL+4nimVBKKasrQUREREREkfN6vUhPT8d7772HxYsXm/ffdNNNaG9vxz/8wz9g2bJlePnll7F69WoAQENDA6ZMmYLnn38e11xzDdasWYO6ujq8++675vPvuusuvPXWW/j666/x17/+FQUFBdiyZQtWrFjRrw4ffPABli1bhvfeew8XX3wxAODtt9/GFVdcgZMnTyIxMfE0p0AUvzhCTkREREQUpw4cOID29nZccsklGDdunPnzwgsv4ODBg+ZyvTvr6enpKCgowL59+wAA+/btw5IlS4Jed8mSJdi/fz/8fj927doFh8OBpUuXDlqXuXPnmuXs7GwAwPHjx6NuI9Fo5rS6AkREREREpKe1tRUA8NZbbyEnJyfoMZfLFdQp15WUlBTWcmPGjDHLQggA3ce3E9HAOEJORERERBSn5syZA5fLhYqKCkyfPj3oJzc311xux44dZrmxsRF//etfMXv2bADA7Nmz8fHHHwe97scff4yZM2fC4XDgnHPOgZQy6Jh0IooNjpATEREREcWplJQU3HnnnbjjjjsgpcSFF14Ij8eDjz/+GKmpqcjLywMAPPjgg5gwYQIyMzPxy1/+EhMnTsTVV18NAPjZz36GhQsX4qGHHsLq1auxfft2PPXUU3j66acBAPn5+Vi7di1uuOEGbNiwAYWFhThy5AiOHz+Oa665xqqmE40K7JATEREREcWxhx56CBkZGSgpKcG3336LtLQ0zJs3D/fcc485ZfyRRx7Bbbfdhv379+Pcc8/FG2+8gYSEBADAvHnz8Mc//hH33XcfHnroIWRnZ+PBBx/EddddZ77Hpk2bcM899+CWW27BiRMnMHXqVNxzzz1WNJdoVOFZ1omIiIiIRqnAGdAbGxuRlpZmdXWIqA8eQ05ERERERERkAXbIiYiIiIiIiCzAKetEREREREREFuAIOREREREREZEF2CEnIiIiIiIisgA75EREREREREQWYIeciIiIiIiIyALskBMRERERERFZgB1yIiIiIiIiIguwQ05ERERERERkAXbIiYiIiIiIiCzw/wHcYd6Bp7efLgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1200x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(\"train\", (12, 6))\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.title(\"Total Train Time(300 epochs)\")\n",
    "plt.bar(\"Compile\", sum(compile_time), 1, label=\"Compile training\", color=\"red\")\n",
    "plt.bar(\"Fast\", sum(eager_time), 1, label=\"Fast training\", color=\"green\")\n",
    "plt.ylabel(\"secs\")\n",
    "plt.grid(alpha=0.4, linestyle=\":\")\n",
    "plt.legend(loc=\"best\")\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.title(\"Epoch Time\")\n",
    "x = [i + 1 for i in range(int(len(compile_time) / step))]\n",
    "plt.xlabel(\"epoch\")\n",
    "plt.ylabel(\"secs\")\n",
    "plt.plot(\n",
    "    x,\n",
    "    [sum(compile_time[i * step : (i + 1) * step]) for i in range(int(len(compile_time) / step))],\n",
    "    label=\"Compile training\",\n",
    "    color=\"red\",\n",
    ")\n",
    "plt.plot(\n",
    "    x,\n",
    "    [sum(eager_time[i * step : (i + 1) * step]) for i in range(int(len(eager_time) / step))],\n",
    "    label=\"Fast training\",\n",
    "    color=\"green\",\n",
    ")\n",
    "plt.grid(alpha=0.4, linestyle=\":\")\n",
    "plt.legend(loc=\"best\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also tried `torch.compile` in [fast_training_tutorial.ipynb](https://github.com/Project-MONAI/tutorials/blob/main/acceleration/fast_training_tutorial.ipynb).\n",
    "The total training time for fast and compile is as follows: 354.9534s and 305.6460s, speedup: 1.16x."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use `torch.compile` with Engine Classes\n",
    "\n",
    "We can simply set `compile=True` in the `SupervisedTrainer` and `SupervisedEvaluator`. Here we convert data to `torch.Tensor` internally if set `compile=True`. Here is the [ticket](https://github.com/pytorch/pytorch/issues/117026) we can track."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_function = monai.losses.DiceCELoss(to_onehot_y=True, softmax=True)\n",
    "trainer = SupervisedTrainer(\n",
    "    device=device,\n",
    "    max_epochs=epoch_num,\n",
    "    train_data_loader=data_loader,\n",
    "    network=model,\n",
    "    optimizer=optimizer,\n",
    "    loss_function=loss_function,\n",
    "    # postprocessing=post_transform,\n",
    "    # amp=args.amp,\n",
    "    # key_train_metric={\n",
    "    #     \"train_dice\": MeanDice(\n",
    "    #         include_background=False,\n",
    "    #         output_transform=from_engine([\"pred\", \"label\"]),\n",
    "    #     )\n",
    "    # },\n",
    "    compile=True,\n",
    "    # you can also add `compile_kwargs` dict of the args for `torch.compile()` API\n",
    "    compile_kwargs={},\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cleanup data directory\n",
    "Remove directory if a temporary was used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "if directory is None:\n",
    "    shutil.rmtree(root_dir)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
